Ejemplo n.º 1
0
        /// <summary>
        /// 合并线节点标识码
        /// </summary>
        //public void MergePolygonLineEntityID(ref LineNodeEx lineNodeBegin, int nIndexBegin, int nIndexEnd)
        //{
        //    if (lineNodeBegin != null && nIndexEnd > 0)
        //    {
        //        bool bNeedFind = true;
        //        int k = nIndexEnd;
        //        //LineNode lineNodeTemp = null;
        //        while (bNeedFind == true)
        //        {
        //            if (k <= nIndexBegin)
        //                break;
        //            LineNodeEx lineNodeK = new LineNodeEx();
        //            //lineNodeTemp = lineNodeK as LineNode;
        //            pLineNodeExTable.GetLineNodeByDataRow(dataTable.Rows[k - 1], ref lineNodeK, false);
        //            LineNodeEx lineNodeKOther = null;
        //            if (lineNodeK.OrtherIndexID > -1 && lineNodeK.OrtherIndexID < dataTableTemp.Rows.Count)
        //            {
        //                lineNodeKOther = new LineNodeEx();
        //                //lineNodeTemp = lineNodeKOther as LineNode;
        //                pLineNodeExTableTemp.GetLineNodeByDataRow(dataTableTemp.Rows[lineNodeK.OrtherIndexID], ref lineNodeKOther, false);
        //            }
        //            else
        //                lineNodeKOther = null;
        //            //不仅仅是最后一个
        //            if ((lineNodeBeginOther != null && lineNodeKOther != null && lineNodeBeginOther.PolygonID == lineNodeKOther.PolygonID)
        //                || (lineNodeBeginOther == null && lineNodeKOther == null && lineNodeBegin.IsFromLine == false && lineNodeK.IsFromLine == false))
        //            {
        //                //合并线
        //                lineNodeK.EntityID = lineNodeBegin.EntityID;
        //                pLineNodeExTable.SetLineNodeEntityID(dataTable.Rows[k - 1], lineNodeBegin.EntityID);
        //                if (lineNodeK.IsReverse != lineNodeBegin.IsReverse)
        //                {
        //                    //若方向不一致
        //                    //lineNodeK.Reverse();
        //                    pLineNodeExTable.ReverseLineNode(dataTable.Rows[k - 1]);
        //                    //在另一个面中的对象也反向
        //                    //if (lineNodeKOther != null)
        //                    //    lineNodeKOther.Reverse();
        //                    if (lineNodeKOther != null)
        //                        pLineNodeExTableTemp.ReverseLineNode(dataTableTemp.Rows[lineNodeK.OrtherIndexID]);
        //                }
        //                k--;
        //            }
        //            else
        //                bNeedFind = false;
        //        }
        //        lineNodeBegin = null;
        //    }
        //}
        //public void MergePolygonLineEntityID(LineNodeExTable pLineNodeExTable, ref LineNodeEx lineNodeBegin, LineNodeEx lineNodeBeginOther, int nIndexBegin, int nIndexEnd, DataTable dataTable, DataTable dataTableTemp, LineNodeExTable pLineNodeExTableTemp)
        //{
        //    if (lineNodeBegin != null && nIndexEnd > 0)
        //    {
        //        bool bNeedFind = true;
        //        int k = nIndexEnd;
        //        //LineNode lineNodeTemp = null;
        //        while (bNeedFind == true)
        //        {
        //            if (k <= nIndexBegin)
        //                break;
        //            LineNodeEx lineNodeK = new LineNodeEx();
        //            //lineNodeTemp = lineNodeK as LineNode;
        //            pLineNodeExTable.GetLineNodeByDataRow(dataTable.Rows[k - 1], ref lineNodeK, false);
        //            LineNodeEx lineNodeKOther = null;
        //            if (lineNodeK.OrtherIndexID > -1 && lineNodeK.OrtherIndexID < dataTableTemp.Rows.Count)
        //            {
        //                lineNodeKOther = new LineNodeEx();
        //                //lineNodeTemp = lineNodeKOther as LineNode;
        //                pLineNodeExTableTemp.GetLineNodeByDataRow(dataTableTemp.Rows[lineNodeK.OrtherIndexID], ref lineNodeKOther, false);
        //            }
        //            else
        //                lineNodeKOther = null;
        //            //不仅仅是最后一个
        //            if ((lineNodeBeginOther != null && lineNodeKOther != null && lineNodeBeginOther.PolygonID == lineNodeKOther.PolygonID)
        //                || (lineNodeBeginOther == null && lineNodeKOther == null && lineNodeBegin.IsFromLine == false && lineNodeK.IsFromLine == false))
        //            {
        //                //合并线
        //                lineNodeK.EntityID = lineNodeBegin.EntityID;
        //                pLineNodeExTable.SetLineNodeEntityID(dataTable.Rows[k - 1], lineNodeBegin.EntityID);
        //                if (lineNodeK.IsReverse != lineNodeBegin.IsReverse)
        //                {
        //                    //若方向不一致
        //                    //lineNodeK.Reverse();
        //                    pLineNodeExTable.ReverseLineNode(dataTable.Rows[k - 1]);
        //                    //在另一个面中的对象也反向
        //                    //if (lineNodeKOther != null)
        //                    //    lineNodeKOther.Reverse();
        //                    if (lineNodeKOther != null)
        //                        pLineNodeExTableTemp.ReverseLineNode(dataTableTemp.Rows[lineNodeK.OrtherIndexID]);
        //                }
        //                k--;
        //            }
        //            else
        //                bNeedFind = false;
        //        }
        //        lineNodeBegin = null;
        //    }
        //}
        /// <summary>
        /// 合并线节点标识码(非引用线)
        /// </summary>
        public void MergeLineEntityID(ref int nNewEntityID)
        {
            if (this.m_pOleDbConnection != null && m_pOleDbConnection.State == ConnectionState.Open)
            {
                MatchLineNodeExView matchLineNodeView = new MatchLineNodeExView(m_pOleDbConnection);
                ModifyEntityIDTable modifyEntityIDTable = new ModifyEntityIDTable(m_pOleDbConnection, true, this.IsFirst);
                ReverseLineNodeTable reverseLineNodeTable = new ReverseLineNodeTable(m_pOleDbConnection, true, this.IsFirst);

                DataTable dataViewLineNodeEx = matchLineNodeView.GetRecords("", "", "");

                bool bNeedSave = false;
                MatchLineNodeEx matchLineNodeUp = null;
                MatchLineNodeEx matchLineNode = null;
                MatchLineNodeEx matchLineBegin = null;
                int n = 0;
                bool bExistUp = false;
                List<MatchLineNodeEx> arrMatchLineNode = new List<MatchLineNodeEx>();
                List<int> arrLineNodeReverse = new List<int>();//记录已经反向的线节点
                while (dataViewLineNodeEx.Rows.Count > 0)
                {
                    for (int i = 0; i < dataViewLineNodeEx.Rows.Count; i++)
                    {
                        matchLineNode = new MatchLineNodeEx();
                        matchLineNodeView.GetLineByDataRow(dataViewLineNodeEx.Rows[i], ref matchLineNode);

                        //if (arrLineNodeReverse.Contains(matchLineNode.LineNodeID))
                        //    matchLineNode.IsReverse = -matchLineNode.IsReverse;

                        if (matchLineNodeUp != null)
                        {
                            //判断当前线节点与上一线节点是否属于同一个面
                            if (matchLineNode.PolygonID == matchLineNodeUp.PolygonID)
                            {
                                //属于同一个面
                                if (bExistUp == true)
                                {
                                    if (matchLineNode.EntityID == 0)//合并处理必须在同一个环内处理
                                    {
                                        //处理环内的首尾节点
                                        //MergePolygonLineEntityID(pLineNodeExTable, ref lineNodeBegin, lineNodeBeginOther, nIndexBegin, i, dataTable, dataTableTemp, pLineNodeExTableTemp);
                                        for (int j = 0; j < arrMatchLineNode.Count; j++)
                                        {
                                            modifyEntityIDTable.AddRow(arrMatchLineNode[j].LineNodeID, matchLineBegin.EntityID);

                                            if (arrMatchLineNode[j].IsReverse != matchLineBegin.IsReverse)
                                            {
                                                //若方向不一致

                                                //在另一个面中的对象也反向
                                                if (arrMatchLineNode[j].OtherLineNodeID != -1)
                                                {
                                                    if (arrMatchLineNode[j].OtherLineNodeID > arrMatchLineNode[j].LineNodeID)
                                                    {
                                                        //arrMatchLineNode[j].IsReverse = -arrMatchLineNode[j].IsReverse;
                                                        reverseLineNodeTable.AddRow(arrMatchLineNode[j].LineNodeID);
                                                        reverseLineNodeTable.AddRow(arrMatchLineNode[j].OtherLineNodeID);
                                                    }
                                                }
                                                else
                                                {
                                                    //arrMatchLineNode[j].IsReverse = -arrMatchLineNode[j].IsReverse;
                                                    reverseLineNodeTable.AddRow(arrMatchLineNode[j].LineNodeID);
                                                }
                                            }
                                            n++;
                                        }
                                        arrMatchLineNode.Clear();

                                        bExistUp = false;
                                    }
                                    else if (matchLineNode.LineIndex - matchLineNodeUp.LineIndex != 1)//(matchLineNode.IsFromLine == "1")//当前线节点是引用线
                                    {
                                        arrMatchLineNode.Clear();
                                        bExistUp = false;
                                    }
                                    else
                                    {
                                        //相邻线节点处理

                                        //线所属的面必须一致
                                        if ((matchLineNode.OtherLineNodeID != -1 && matchLineNodeUp.OtherLineNodeID != -1 && matchLineNode.OtherPolygonID == matchLineNodeUp.OtherPolygonID)
                                            || (matchLineNode.OtherLineNodeID == -1 && matchLineNodeUp.OtherLineNodeID == -1))
                                        {
                                            //合并线
                                            matchLineNode.EntityID = matchLineNodeUp.EntityID;
                                            modifyEntityIDTable.AddRow(matchLineNode.LineNodeID, matchLineNodeUp.EntityID);

                                            if (matchLineNode.IsReverse != matchLineNodeUp.IsReverse)
                                            {
                                                //若方向不一致

                                                //在另一个面中的对象也反向
                                                if (matchLineNode.OtherLineNodeID != -1)
                                                {
                                                    if (matchLineNode.OtherLineNodeID > matchLineNode.LineNodeID)
                                                    {
                                                        matchLineNode.IsReverse = -matchLineNode.IsReverse;
                                                        reverseLineNodeTable.AddRow(matchLineNode.LineNodeID);
                                                        reverseLineNodeTable.AddRow(matchLineNode.OtherLineNodeID);
                                                    }
                                                }
                                                else
                                                {
                                                    matchLineNode.IsReverse = -matchLineNode.IsReverse;
                                                    reverseLineNodeTable.AddRow(matchLineNode.LineNodeID);
                                                }

                                            }
                                            n++;
                                        }
                                        else
                                        {
                                            if (arrMatchLineNode.Count > 0)
                                                arrMatchLineNode.Clear();
                                        }

                                        if (matchLineNode.EntityID != matchLineBegin.EntityID)
                                        {
                                            if ((matchLineNode.OtherLineNodeID != -1 && matchLineBegin.OtherLineNodeID != -1 && matchLineNode.OtherPolygonID == matchLineBegin.OtherPolygonID)
                                                || (matchLineNode.OtherLineNodeID == -1 && matchLineBegin.OtherLineNodeID == -1))
                                            {
                                                arrMatchLineNode.Add(matchLineNode);
                                            }
                                        }
                                    }
                                }
                                else
                                {
                                    arrMatchLineNode.Clear();
                                    matchLineBegin = matchLineNode;
                                    bExistUp = true;
                                }
                            }
                            else
                            {
                                //不属于同一个面(处理首尾节点)
                                //MergePolygonLineEntityID(pLineNodeExTable, ref lineNodeBegin, lineNodeBeginOther, nIndexBegin, i, dataTable, dataTableTemp, pLineNodeExTableTemp);
                                for (int j = 0; j < arrMatchLineNode.Count; j++)
                                {
                                    modifyEntityIDTable.AddRow(arrMatchLineNode[j].LineNodeID, matchLineBegin.EntityID);

                                    if (arrMatchLineNode[j].IsReverse != matchLineBegin.IsReverse)
                                    {
                                        //若方向不一致

                                        //在另一个面中的对象也反向
                                        if (arrMatchLineNode[j].OtherLineNodeID != -1)
                                        {
                                            if (arrMatchLineNode[j].OtherLineNodeID > arrMatchLineNode[j].LineNodeID)
                                            {
                                                //arrMatchLineNode[j].IsReverse = -arrMatchLineNode[j].IsReverse;
                                                reverseLineNodeTable.AddRow(arrMatchLineNode[j].LineNodeID);
                                                reverseLineNodeTable.AddRow(arrMatchLineNode[j].OtherLineNodeID);
                                            }
                                        }
                                        else
                                        {
                                            //arrMatchLineNode[j].IsReverse = -arrMatchLineNode[j].IsReverse;
                                            reverseLineNodeTable.AddRow(arrMatchLineNode[j].LineNodeID);
                                        }
                                    }
                                    n++;
                                }
                                arrMatchLineNode.Clear();
                                matchLineBegin = matchLineNode;
                                bExistUp = true;
                            }

                        }
                        else
                        {
                            matchLineBegin = matchLineNode;
                            bExistUp = true;
                        }

                        if (matchLineNode.EntityID == -1)
                        {
                            matchLineNode.EntityID = nNewEntityID++;
                            modifyEntityIDTable.AddRow(matchLineNode.LineNodeID, matchLineNode.EntityID);
                        }

                        matchLineNodeUp = matchLineNode;
                    }
                    if (n > modifyEntityIDTable.MaxRecordCount)
                    {
                        modifyEntityIDTable.Save(true);
                        reverseLineNodeTable.Save(true);
                        bNeedSave = true;
                        n = 0;
                    }

                    if (dataViewLineNodeEx.Rows.Count < matchLineNodeView.MaxRecordCount)
                        break;
                    dataViewLineNodeEx = matchLineNodeView.GetNextRecords();
                }

                //MergePolygonLineEntityID(pLineNodeExTable, ref lineNodeBegin, lineNodeBeginOther, nIndexBegin, dataTable.Rows.Count, dataTable, dataTableTemp, pLineNodeExTableTemp);
                for (int j = 0; j < arrMatchLineNode.Count; j++)
                {
                    modifyEntityIDTable.AddRow(arrMatchLineNode[j].LineNodeID, matchLineBegin.EntityID);

                    if (arrMatchLineNode[j].IsReverse != matchLineBegin.IsReverse)
                    {
                        //若方向不一致

                        //在另一个面中的对象也反向
                        if (arrMatchLineNode[j].OtherLineNodeID != -1)
                        {
                            if (arrMatchLineNode[j].OtherLineNodeID > arrMatchLineNode[j].LineNodeID)
                            {
                                //arrMatchLineNode[j].IsReverse = -arrMatchLineNode[j].IsReverse;
                                reverseLineNodeTable.AddRow(arrMatchLineNode[j].LineNodeID);
                                reverseLineNodeTable.AddRow(arrMatchLineNode[j].OtherLineNodeID);
                            }
                        }
                        else
                        {
                            //arrMatchLineNode[j].IsReverse = -arrMatchLineNode[j].IsReverse;
                            reverseLineNodeTable.AddRow(arrMatchLineNode[j].LineNodeID);
                        }
                    }

                }
                arrMatchLineNode.Clear();

                if (n > 0)
                {
                    modifyEntityIDTable.Save(true);
                    reverseLineNodeTable.Save(true);
                    bNeedSave = true;
                }
                if (bNeedSave == true)
                {
                    //删除冗余记录
                    modifyEntityIDTable.DeleteSurplusRows();
                    reverseLineNodeTable.DeleteSurplusRows();

                    //更新标识码
                    string strCommand = "";
                    strCommand = "Update LineNodeEx,ModifyEntityID Set LineNodeEx.EntityID=ModifyEntityID.EntityID Where LineNodeEx.LineNodeID=ModifyEntityID.LineNodeID";
                    modifyEntityIDTable.ExecuteNonQuery(strCommand);

                    //更新反向标识
                    strCommand = "Update LineNodeEx Set IsReverse=-IsReverse Where LineNodeID In ( Select LineNodeID From ReverseLineNode )";//反向
                    reverseLineNodeTable.ExecuteNonQuery(strCommand);
                }
            }

            /*
            if (this.m_pOleDbConnection != null && m_pOleDbConnection.State == ConnectionState.Open)
            {
                LineNodeExTable pLineNodeExTable = new LineNodeExTable(m_pOleDbConnection, false);

                string strLineNodeExOrderBy = pLineNodeExTable.FieldName_PolygonID + "," + pLineNodeExTable.FieldName_LineIndex;
                DataTable dataTable = pLineNodeExTable.GetRecords("", "", strLineNodeExOrderBy);

                string strLineNodeExOrderByTemp = pLineNodeExTable.FileName_LineNodeID;
                LineNodeExTable pLineNodeExTableTemp = new LineNodeExTable(m_pOleDbConnection, false);
                DataTable dataTableTemp = pLineNodeExTableTemp.GetRecords("", "", strLineNodeExOrderByTemp);

                LineNodeEx lineNodeUp = null;
                LineNodeEx lineNodeUpOther = null;
                LineNodeEx lineNodeCurrent = null;
                LineNodeEx lineNodeCurrentOther = null;
                LineNodeEx lineNodeBegin = null;
                LineNodeEx lineNodeBeginOther = null;
                bool bExistUp = false;
                int nIndexBegin = -1;

                for (int i = 0; i < dataTable.Rows.Count; i++)
                {
                    //获取当前线节点
                    lineNodeCurrent = new LineNodeEx();
                    //LineNode lineNodeTemp = lineNodeCurrent as LineNode;
                    pLineNodeExTable.GetLineNodeByDataRow(dataTable.Rows[i], ref lineNodeCurrent, false);
                    if (lineNodeCurrent.OrtherIndexID > -1 && lineNodeCurrent.OrtherIndexID < dataTableTemp.Rows.Count)
                    {
                        lineNodeCurrentOther = new LineNodeEx();
                        //lineNodeTemp = lineNodeCurrentOther as LineNode;
                        pLineNodeExTableTemp.GetLineNodeByDataRow(dataTableTemp.Rows[lineNodeCurrent.OrtherIndexID], ref lineNodeCurrentOther, false);
                    }
                    else
                        lineNodeCurrentOther = null;

                    if (lineNodeBegin == null)
                    {
                        lineNodeBegin = lineNodeCurrent;
                        lineNodeBeginOther = lineNodeCurrentOther;
                        nIndexBegin = i;
                    }

                    if (i > 0)
                    {
                        //判断当前线节点与上一线节点是否属于同一个面
                        if (lineNodeCurrent.PolygonID == lineNodeUp.PolygonID)
                        {
                            //属于同一个面
                            if (bExistUp == true)
                            {
                                if (lineNodeCurrent.EntityID == 0)//合并处理必须在同一个环内处理
                                {
                                    //处理环内的首尾节点
                                    MergePolygonLineEntityID(pLineNodeExTable, ref lineNodeBegin, lineNodeBeginOther, nIndexBegin, i, dataTable, dataTableTemp, pLineNodeExTableTemp);

                                    bExistUp = false;
                                }
                                else if (lineNodeCurrent.IsFromLine == true)//当前线节点是引用线
                                {
                                    bExistUp = false;
                                }
                                else
                                {
                                    //相邻线节点处理

                                    //线所属的面必须一致
                                    if ((lineNodeCurrentOther != null && lineNodeUpOther != null && lineNodeCurrentOther.PolygonID == lineNodeUpOther.PolygonID)
                                        || (lineNodeCurrentOther == null && lineNodeUpOther == null && lineNodeCurrent.IsFromLine == false && lineNodeUp.IsFromLine == false))
                                    {
                                        //合并线
                                        lineNodeCurrent.EntityID = lineNodeUp.EntityID;
                                        pLineNodeExTable.SetLineNodeEntityID(dataTable.Rows[i], lineNodeUp.EntityID);

                                        if (lineNodeCurrent.IsReverse != lineNodeUp.IsReverse)
                                        {
                                            //若方向不一致
                                            //lineNodeCurrent.Reverse();
                                            pLineNodeExTable.ReverseLineNode(dataTable.Rows[i]);
                                            //在另一个面中的对象也反向
                                            //if (lineNodeCurrent.OtherPolygonLineNode != null)
                                            //    lineNodeCurrent.OtherPolygonLineNode.Reverse();
                                            if (lineNodeCurrentOther != null)
                                                pLineNodeExTableTemp.ReverseLineNode(dataTableTemp.Rows[lineNodeCurrent.OrtherIndexID]);
                                        }
                                    }
                                }
                            }
                            else
                            {
                                bExistUp = true;
                            }

                        }
                        else
                        {
                            //不属于同一个面(处理首尾节点)
                            MergePolygonLineEntityID(pLineNodeExTable, ref lineNodeBegin, lineNodeBeginOther, nIndexBegin, i, dataTable, dataTableTemp, pLineNodeExTableTemp);

                            lineNodeBegin = lineNodeCurrent;
                            lineNodeBeginOther = lineNodeCurrentOther;
                            nIndexBegin = i;
                            bExistUp = true;
                        }
                    }
                    lineNodeUp = lineNodeCurrent;
                    lineNodeUpOther = lineNodeCurrentOther;

                    if ((i + 1) % 10000 == 0)
                    {
                        pLineNodeExTable.Save(false);
                        pLineNodeExTableTemp.Save(false);
                    }
                }

                MergePolygonLineEntityID(pLineNodeExTable, ref lineNodeBegin, lineNodeBeginOther, nIndexBegin, dataTable.Rows.Count, dataTable, dataTableTemp, pLineNodeExTableTemp);

                pLineNodeExTable.Save(true);
                pLineNodeExTableTemp.Save(true);
            }
             * */
        }
Ejemplo n.º 2
0
        ///// <summary>
        ///// 处理线段在一个面中连续,另一个面中不连续的情况
        ///// </summary>
        //public void SplitPolygonLineNode(LineNodeExTable pLineNodeExTable,List<int> arrSplitEntityID, int nBeginPolygonIndex, int nEndPolygonIndex,
        //    DataTable dataTable, DataTable dataTableTemp, LineNodeExTable pLineNodeExTableTemp)
        //{
        //    LineNodeEx lineNodeK = null;
        //    LineNodeEx lineNodeKOther = null;
        //    //LineNode lineNodeTemp = null;
        //    for (int j = 0; j < arrSplitEntityID.Count; j++)
        //    {
        //        for (int k = nBeginPolygonIndex; k < nEndPolygonIndex; k++)
        //        {
        //            lineNodeK = new LineNodeEx();
        //            //lineNodeTemp = lineNodeK as LineNode;
        //            pLineNodeExTable.GetLineNodeByDataRow(dataTable.Rows[k], ref lineNodeK, false);
        //            if (lineNodeK.OrtherIndexID > -1 && lineNodeK.OrtherIndexID < dataTableTemp.Rows.Count)
        //            {
        //                lineNodeKOther = new LineNodeEx();
        //                //lineNodeTemp = lineNodeKOther as LineNode;
        //                pLineNodeExTableTemp.GetLineNodeByDataRow(dataTableTemp.Rows[lineNodeK.OrtherIndexID], ref lineNodeKOther, false);
        //            }
        //            else
        //                lineNodeKOther = null;
        //            if (lineNodeKOther != null)
        //            {
        //                if (arrSplitEntityID[j] == lineNodeKOther.EntityID)
        //                {
        //                    if (lineNodeKOther.IsReverse == false)
        //                    {
        //                        //lineNodeKOther.Reverse();
        //                        pLineNodeExTableTemp.ReverseLineNode(dataTableTemp.Rows[lineNodeK.OrtherIndexID]);
        //                        //lineNodeK.Reverse();
        //                        pLineNodeExTable.ReverseLineNode(dataTable.Rows[k]);
        //                    }
        //                }
        //            }
        //        }
        //    }
        //}
        /// <summary>
        /// 处理线段在一个面中连续,另一个面中不连续的情况
        /// </summary>
        public void SplitLineNode()
        {
            if (this.m_pOleDbConnection != null && m_pOleDbConnection.State == ConnectionState.Open)
            {
                ReverseLineNodeTable pReverseLineNodeTable = new ReverseLineNodeTable(m_pOleDbConnection, true, false);

                MatchLineNodeExView pMatchLineNodeView = new MatchLineNodeExView(m_pOleDbConnection);
                DataTable dataViewLineNodeEx = pMatchLineNodeView.GetRecords("", "", "");

                MatchLineNodeEx matchLineNodeUp = null;
                MatchLineNodeEx matchLineNode = null;

                List<MatchLineNodeEx> arrMatchLineNode = new List<MatchLineNodeEx>();
                List<int> arrAllEntityID = new List<int>();
                List<int> arrSplitEntityID = new List<int>();
                int nReverseCount = 0;
                bool bNeedSave = false;
                while (dataViewLineNodeEx.Rows.Count > 0)
                {
                    for (int i = 0; i < dataViewLineNodeEx.Rows.Count; i++)
                    {
                        matchLineNode = new MatchLineNodeEx();
                        pMatchLineNodeView.GetLineByDataRow(dataViewLineNodeEx.Rows[i], ref matchLineNode);

                        if (matchLineNode.OtherEntityID > 0 && matchLineNode.IsReverse == -1)
                        {
                            arrMatchLineNode.Add(matchLineNode);
                        }

                        if (matchLineNodeUp != null)
                        {
                            //判断当前线节点与上一线节点是否属于同一个面
                            if (matchLineNode.PolygonID != matchLineNodeUp.PolygonID)
                            {
                                if (arrSplitEntityID.Count > 0)
                                {
                                    for (int j = 0; j < arrMatchLineNode.Count; j++)
                                    {
                                        if (arrSplitEntityID.Contains(matchLineNode.EntityID) == true)
                                        {
                                            pReverseLineNodeTable.AddRow(arrMatchLineNode[j].LineNodeID);
                                            pReverseLineNodeTable.AddRow(arrMatchLineNode[j].OtherLineNodeID);
                                            nReverseCount++;
                                        }
                                    }
                                }
                                arrMatchLineNode.Clear();
                                arrAllEntityID.Clear();
                                arrSplitEntityID.Clear();
                            }
                            else
                            {
                                if (matchLineNode.OtherEntityID != matchLineNodeUp.OtherEntityID)
                                {
                                    if (matchLineNode.OtherEntityID > 0 && matchLineNode.IsReverse == -1)
                                    {
                                        if (arrAllEntityID.Contains(matchLineNode.OtherEntityID) == false)
                                        {
                                            arrAllEntityID.Add(matchLineNode.OtherEntityID);
                                        }
                                        else
                                        {
                                            arrSplitEntityID.Add(matchLineNode.OtherEntityID);
                                        }
                                    }
                                }
                            }
                        }

                        if (arrAllEntityID.Count == 0)
                            arrAllEntityID.Add(matchLineNode.OtherEntityID);

                        matchLineNodeUp = matchLineNode;
                    }
                    if (nReverseCount > pReverseLineNodeTable.MaxRecordCount)
                    {
                        pReverseLineNodeTable.Save(true);
                        nReverseCount = 0;
                        bNeedSave = true;
                    }

                    if (dataViewLineNodeEx.Rows.Count < pMatchLineNodeView.MaxRecordCount)
                        break;
                    dataViewLineNodeEx = pMatchLineNodeView.GetNextRecords();
                }

                if (arrSplitEntityID.Count > 0)
                {
                    for (int j = 0; j < arrMatchLineNode.Count; j++)
                    {
                        if (arrSplitEntityID.Contains(matchLineNode.EntityID) == true)
                        {
                            pReverseLineNodeTable.AddRow(arrMatchLineNode[j].LineNodeID);
                            pReverseLineNodeTable.AddRow(arrMatchLineNode[j].OtherLineNodeID);
                            nReverseCount++;
                        }
                    }
                }
                arrMatchLineNode.Clear();
                arrAllEntityID.Clear();
                arrSplitEntityID.Clear();

                if (nReverseCount > 0)
                {
                    pReverseLineNodeTable.Save(true);
                    bNeedSave = true;
                }

                if (bNeedSave == true)
                {
                    //删除冗余记录
                    pReverseLineNodeTable.DeleteSurplusRows();

                    //更新反向标识
                    string strCommand = "Update LineNodeEx Set IsReverse=0-IsReverse Where LineNodeID In ( Select LineNodeID From ReverseLineNode )";//反向
                    pReverseLineNodeTable.ExecuteNonQuery(strCommand);
                }
                //LineNodeExTable pLineNodeExTable = new LineNodeExTable(m_pOleDbConnection, false);

                //string strLineNodeExOrderBy = pLineNodeExTable.FieldName_PolygonID + "," + pLineNodeExTable.FieldName_LineIndex;
                //DataTable dataTable = pLineNodeExTable.GetRecords("", "", strLineNodeExOrderBy);

            //    //string strLineNodeExOrderByTemp = pLineNodeExTable.FileName_LineNodeID;
            //    //LineNodeExTable pLineNodeExTableTemp = new LineNodeExTable(m_pOleDbConnection, false);
            //    //DataTable dataTableTemp = pLineNodeExTableTemp.GetRecords("", "", strLineNodeExOrderByTemp);

            //    LineNodeEx lineNodeUp = null;
            //    //LineNodeEx lineNodeUpOther = null;
            //    LineNodeEx lineNodeCurrent = null;
            //    //LineNodeEx lineNodeCurrentOther = null;

            //    List<int> arrAllEntityID = new List<int>();
            //    List<int> arrSplitEntityID = new List<int>();
            //    int nBeginPolygonIndex = 0;
            //    for (int i = 0; i < dataTable.Rows.Count; i++)
            //    {
            //        lineNodeCurrent = new LineNodeEx();
            //        pLineNodeExTable.GetLineNodeByDataRow(dataTable.Rows[i], ref lineNodeCurrent, false);
            //        //if (lineNodeCurrent.OrtherIndexID > -1 && lineNodeCurrent.OrtherIndexID < dataTableTemp.Rows.Count)
            //        //{
            //        //    lineNodeCurrentOther = new LineNodeEx();
            //        //    pLineNodeExTableTemp.GetLineNodeByDataRow(dataTableTemp.Rows[lineNodeCurrent.OrtherIndexID], ref lineNodeCurrentOther, false);
            //        //}
            //        //else
            //        //    lineNodeCurrentOther = null;

            //        if (i == 0)
            //        {
            //            //if(lineNodeCurrent.OrtherIndexID!=-1)
            //            //arrAllEntityID.Add(lineNodeCurrentOther.EntityID);
            //        }

            //        if (i > 0)
            //        {
            //            //判断当前线节点与上一线节点是否属于同一个面
            //            if (lineNodeCurrent.PolygonID != lineNodeUp.PolygonID)
            //            {
            //                SplitPolygonLineNode(pLineNodeExTable, arrSplitEntityID, nBeginPolygonIndex, i, dataTable, dataTableTemp, pLineNodeExTableTemp);

            //                nBeginPolygonIndex = i;
            //                arrAllEntityID.Clear();
            //                arrSplitEntityID.Clear();
            //            }
            //            else
            //            {
            //                if (lineNodeCurrent.OrtherIndexID != -1)
            //                {

            //                    if (lineNodeUp.OrtherIndexID == -1 ||
            //                        lineNodeCurrentOther.EntityID != lineNodeUpOther.EntityID)
            //                    {
            //                        if (arrAllEntityID.Contains(lineNodeCurrentOther.EntityID) == false)
            //                        {
            //                            arrAllEntityID.Add(lineNodeCurrentOther.EntityID);
            //                        }
            //                        else
            //                        {
            //                            arrSplitEntityID.Add(lineNodeCurrentOther.EntityID);
            //                        }
            //                    }
            //                }

            //            }
            //        }

            //        if ((i + 1) % 10000 == 0)
            //        {
            //            pLineNodeExTable.Save(false);
            //            pLineNodeExTableTemp.Save(false);
            //        }

            //        lineNodeUp = lineNodeCurrent;
            //        //lineNodeUpOther = lineNodeCurrentOther;
            //    }

            //    SplitPolygonLineNode(pLineNodeExTable, arrSplitEntityID, nBeginPolygonIndex, dataTable.Rows.Count, dataTable, dataTableTemp, pLineNodeExTableTemp);

            //    pLineNodeExTable.Save(true);
            //    pLineNodeExTableTemp.Save(true);
            }
        }