Example #1
0
        /// <summary>
        /// 保存面图层对应的线图层中的实体到临时数据文件
        /// </summary>
        private void SaveLineNodesToTemp(LineNodeTable pLineNodeTable,string strPolygonTableName)
        {
            //暂时不考虑面与面之间的关联
            MetaTable metaTable = MetaDataFile.GetMetaTalbleByName(strPolygonTableName);
            List<string> arrFeatureCode = null;
            if (metaTable != null)
                arrFeatureCode = metaTable.LinkFeatureCode;
            if (arrFeatureCode != null && arrFeatureCode.Count > 0)
            {
                ESRIData.FeatureLayer featureLayer;
                int m = 1;
                for (int i = 0; i < m_nLayerCount; i++)
                {
                    //获取图层对象
                    featureLayer = m_dataset.GetFeatureLayerByIndex(i) as ESRIData.FeatureLayer;
                    ESRIData.LineLayer lineLayer = featureLayer as ESRIData.LineLayer;
                    if (lineLayer != null)
                    {
                        if (arrFeatureCode.Contains(lineLayer.FeatureCode) == true)
                        {
                            List<ESRIData.FeatureEntity> arrFeatureEntity = lineLayer.FeatureEntys;
                            if (arrFeatureEntity == null) return;
                            for (int j = 0; j < arrFeatureEntity.Count; j++)
                            {
                                FileData.LineNode lineNode = arrFeatureEntity[j].GetEntityNode() as FileData.LineNode;
                                if (lineNode != null)
                                {
                                    //拆分线:多点一线拆为两点一线
                                    for (int k = 0; k < lineNode.SegmentNodes.Count; k++)
                                    {
                                        FileData.BrokenLineNode brokenLineNode = lineNode.SegmentNodes[k] as FileData.BrokenLineNode;
                                        if (brokenLineNode != null)
                                        {
                                            for (int n = 1; n < brokenLineNode.PointInfoNodes.Count; n++)
                                            {
                                                FileData.PointInfoNodes pointInfoNodes = new FileData.PointInfoNodes();
                                                pointInfoNodes.Add(brokenLineNode.PointInfoNodes[n - 1]);
                                                pointInfoNodes.Add(brokenLineNode.PointInfoNodes[n]);

                                                FileData.BrokenLineNode brokenLineNodeNew = new FileData.BrokenLineNode();
                                                brokenLineNodeNew.PointInfoNodes = pointInfoNodes;

                                                FileData.SegmentNodes segmentNodes = new FileData.SegmentNodes();
                                                segmentNodes.Add(brokenLineNodeNew);

                                                FileData.LineNode lineNodeNew = new FileData.LineNode();
                                                lineNodeNew.SegmentNodes = segmentNodes;

                                                lineNodeNew.EntityID = lineNode.EntityID;
                                                lineNodeNew.FeatureCode = lineNode.FeatureCode;
                                                lineNodeNew.LineType = lineNode.LineType;
                                                lineNodeNew.Representation = lineNode.Representation;

                                                //arrLineNode.Add(lineNodeNew);
                                                //写入临时数据文件
                                                //if (m_pTempFile.LineNodeExs != null)
                                                //{
                                                pLineNodeTable.AddRow(lineNodeNew);
                                                //}

                                                if (m % pLineNodeTable.MaxRecordCount == 0)
                                                    pLineNodeTable.Save(true);
                                                m++;
                                            }
                                        }
                                    }

                                }
                            }
                        }

                    }
                }

                pLineNodeTable.Save(true);

            }
            //return arrLineNode;
        }
Example #2
0
        /// <summary>
        /// 写入面节点
        /// </summary>
        public void Write()
        {
            if (m_pTempFile.DbConnection != null && m_pTempFile.DbConnection.State == ConnectionState.Open)
            {
                ESRIData.FeatureLayer featureLayer;
                while (this.m_nLayerIndex < m_nLayerCount)
                {
                    //获取图层对象
                    featureLayer = m_dataset.GetFeatureLayerByIndex(this.m_nLayerIndex) as ESRIData.FeatureLayer;
                    ESRIData.PolygonLayer polygonLayer = featureLayer as ESRIData.PolygonLayer;
                    if (polygonLayer != null)
                    {
                        List<ESRIData.FeatureEntity> arrFeatureEntity = polygonLayer.FeatureEntys;
                        if (arrFeatureEntity!=null&&arrFeatureEntity.Count > 0)
                        {
                            m_pTempFile.IsFirst = m_bIsFirst;

                            ////清除临时数据
                            PolygonNodeTable pPolygonNodeTable = new PolygonNodeTable(m_pTempFile.DbConnection, true, m_bIsFirst);
                            LineNodeExTable pLineNodeExTable = new LineNodeExTable(m_pTempFile.DbConnection, true, m_bIsFirst);
                            LineNodeTable pLineNodeTable = new LineNodeTable(m_pTempFile.DbConnection, true, m_bIsFirst);

                            ///处理每个图层下的所有要素
                            //using (BackgroundWorker workerPolygon = new BackgroundWorker())
                            //{
                            //    workerPolygon.DoWork += delegate
                            //    {
                                    timeBeginPolygon = DateTime.Now;

                                    int j = 1, n = 1;
                                    FileData.PolygonNode polygonNode = null;
                                    while (arrFeatureEntity.Count > 0)
                                    {
                                        polygonNode = arrFeatureEntity[0].GetEntityNode() as FileData.PolygonNode;
                                        if (polygonNode != null)
                                        {
                                            pPolygonNodeTable.AddRow(polygonNode);

                                            for (int k = 0; k < polygonNode.LineNodes.Count; k++)
                                            {
                                                polygonNode.LineNodes[k].LineIndex = k;
                                                pLineNodeExTable.AddRow(polygonNode.LineNodes[k]);
                                                if (n % pLineNodeExTable.MaxRecordCount == 0)
                                                    pLineNodeExTable.Save(true);
                                                n++;
                                            }
                                        }

                                        //m_pTempFile.PolygonNodes.AddRow(polygonNode);
                                        if (j % pPolygonNodeTable.MaxRecordCount == 0 || 1 == arrFeatureEntity.Count)
                                        {
                                            //if (j == arrFeatureEntity.Count)
                                            pLineNodeExTable.Save(true);
                                            pPolygonNodeTable.Save(true);
                                        }
                                        arrFeatureEntity.RemoveAt(0);
                                        j++;
                                    }
                                    TimeSpan span = DateTime.Now - this.timeBeginPolygon;
                                    LogAPI.WriteLog("写入构面线临时数据耗时" + span.ToString());

                            //    };

                            //    workerPolygon.RunWorkerCompleted += WritePolygonCompleted;

                            //    workerPolygon.RunWorkerAsync();
                            //}

                            //保存关联的线图层中的线结点到临时图层/*
                            //using (BackgroundWorker workerLine = new BackgroundWorker())
                            //{
                            timeBeginLine = DateTime.Now;
                            //    workerLine.DoWork += delegate
                            //    {
                            SaveLineNodesToTemp(pLineNodeTable, featureLayer.StructureNode.TableName);
                            span = DateTime.Now - this.timeBeginLine;
                            LogAPI.WriteLog("写入引用线临时数据耗时" + span.ToString());

                            //    };

                            //    workerLine.RunWorkerCompleted += WriteLineCompleted;

                            //    workerLine.RunWorkerAsync();

                            //};

                            WritePolygonLineCompleted();

                            if (m_bIsFirst == true)
                                m_bIsFirst = false;
                        }
                        break;
                    }
                    else
                        this.m_nLayerIndex++;
                }
                //if (this.m_nLayerIndex == m_nLayerCount)
                //{
                //    m_pTempFile.Close();
                //    if (WriteCommplete != null)
                //        WriteCommplete(true);
                //}
            }
        }
Example #3
0
        /// <summary>
        /// 处理面图层中构面线与线图层(与面图层关联)中的线对象之间的关系
        /// </summary>
        public void MatchPolygonToLine()
        {
            /*          string strCommand ="";
                      strCommand = "Update LineNodeEx,LineNode Set LineNodeEx.EntityID=LineNode.EntityID,LineNodeEx.IsFromLine='1' Where"
                      +" (LineNodeEx.X1-LineNode.X1)<0.000001 and (LineNodeEx.X1-LineNode.X1)>-0.000001 "
                      +"and (LineNodeEx.Y1-LineNode.Y1)<0.000001 and (LineNodeEx.Y1-LineNode.Y1)>-0.000001  "
                      +"and (LineNodeEx.X2-LineNode.X2)<0.000001 and (LineNodeEx.X2-LineNode.X2)>-0.000001  "
                      +"and (LineNodeEx.Y2-LineNode.Y2)<0.000001 and (LineNodeEx.Y2-LineNode.Y2)>-0.000001 and LineNodeEx.EntityID=-1";
                      pLineNodeExTable.ExecuteNonQuery(strCommand);

                      strCommand = "Update LineNodeEx,LineNode Set LineNodeEx.EntityID=LineNode.EntityID,LineNodeEx.IsFromLine='1' Where"
                       + "(LineNodeEx.X2-LineNode.X1)<0.000001 and (LineNodeEx.X2-LineNode.X1)>-0.000001 "
                      + "and (LineNodeEx.Y2-LineNode.Y1)<0.000001 and (LineNodeEx.Y2-LineNode.Y1)>-0.000001  "
                      + "and (LineNodeEx.X1-LineNode.X2)<0.000001 and (LineNodeEx.X1-LineNode.X2)>-0.000001  "
                      + "and (LineNodeEx.Y1-LineNode.Y2)<0.000001 and (LineNodeEx.Y1-LineNode.Y2)>-0.000001 and LineNodeEx.EntityID=-1";

                      pLineNodeExTable.ExecuteNonQuery(strCommand);

              */

            if (this.m_pOleDbConnection != null && m_pOleDbConnection.State == ConnectionState.Open)
            {
                LineNodeTable pLineNodeTable = new LineNodeTable(m_pOleDbConnection);
                //pLineNodeTable.MaxRecordCount = 500000;
                LineNodeExTable pLineNodeExTable = new LineNodeExTable(m_pOleDbConnection);
                //pLineNodeExTable.MaxRecordCount = 500000;
                MatchLineNodeTable pMatchLineNodeTable = new MatchLineNodeTable(m_pOleDbConnection, true, this.IsFirst);

                string strLineNodeExWhere = pLineNodeExTable.FieldName_EntityID + "=-1";
                string strLineNodeExOrderBy = pLineNodeExTable.FieldName_X1 + ","
                    + pLineNodeExTable.FieldName_Y1 + ","
                    + pLineNodeExTable.FieldName_X2 + ","
                    + pLineNodeExTable.FieldName_Y2 + ","
                    + pLineNodeExTable.FieldName_EntityID;
                string strLineNodeWhere = pLineNodeTable.FieldName_EntityID + ">0";
                string strLineNodeOrderBy = pLineNodeTable.FieldName_X1 + ","
                    + pLineNodeTable.FieldName_Y1 + ","
                    + pLineNodeTable.FieldName_X2 + ","
                    + pLineNodeTable.FieldName_Y2 + ","
                    + pLineNodeTable.FieldName_EntityID;

                DataTable dataTableLineNodeEx = pLineNodeExTable.GetRecords(strLineNodeExWhere, "", strLineNodeExOrderBy);
                DataTable dataTableLineNode = pLineNodeTable.GetRecords(strLineNodeWhere, "", strLineNodeOrderBy);

                if (dataTableLineNode.Rows.Count == 0 || dataTableLineNodeEx.Rows.Count == 0)
                    return;

                //更新构面线的标识码
                bool bNeedSave = false;
                int j = 0;
                int i = 0;
                int n = 0;
                while (dataTableLineNode.Rows.Count > 0)
                {
                    for (i = 0; i < dataTableLineNode.Rows.Count; i++)
                    {
                        if (j == dataTableLineNodeEx.Rows.Count)
                            break;

                        LineNodeSimple lineNode = new LineNodeSimple();
                        pLineNodeTable.GetLineNodeByDataRow(dataTableLineNode.Rows[i], ref lineNode, false);

                        while (dataTableLineNodeEx.Rows.Count > 0)
                        {
                            for (; j < dataTableLineNodeEx.Rows.Count; j++)
                            {
                                LineNodeSimple lineNodeEx = new LineNodeSimple();
                                pLineNodeExTable.GetLineNodeByDataRow(dataTableLineNodeEx.Rows[j], ref lineNodeEx, false);

                                if (lineNode == lineNodeEx)
                                {
                                    pMatchLineNodeTable.AddRow(lineNode.IndexID, lineNodeEx.IndexID, lineNode.EntityID);
                                    n++;
                                    //pLineNodeExTable.SetLineNodeFromLine(dataTableLineNodeEx.Rows[j], lineNode.EntityID, false);
                                    //if (bNeedSave == false)
                                    //    bNeedSave = true;
                                }
                                else if (lineNode > lineNodeEx)
                                {

                                }
                                else
                                {
                                    break;
                                }
                            }

                            if (j == dataTableLineNodeEx.Rows.Count)
                            {
                                if (dataTableLineNodeEx.Rows.Count < pLineNodeExTable.MaxRecordCount)
                                    break;
                                dataTableLineNodeEx = pLineNodeExTable.GetNextRecords();
                                j = 0;
                            }
                            else
                                break;
                        }
                    }

                    if (n >= pMatchLineNodeTable.MaxRecordCount)
                    {
                        bNeedSave = true;
                        pMatchLineNodeTable.Save(true);
                        n = 0;
                    }

                    if (i == dataTableLineNode.Rows.Count)
                    {
                        if (dataTableLineNode.Rows.Count < pLineNodeTable.MaxRecordCount)
                            break;
                        dataTableLineNode = pLineNodeTable.GetNextRecords();
                    }
                    else
                        break;
                }
                if (n > 0)
                {
                    bNeedSave = true;
                    pMatchLineNodeTable.Save(true);
                    n = 0;
                }

                if (bNeedSave == true)
                {
                    string strCommand = "Update " + pLineNodeExTable.TableName_TempTable + "," + pMatchLineNodeTable.TableName_TempTable + " Set "
                        + pLineNodeExTable.TableName_TempTable + "." + pLineNodeExTable.FieldName_EntityID + "=" + pMatchLineNodeTable.TableName_TempTable+"." + pMatchLineNodeTable.FieldName_EntityID + ","
                        + pLineNodeExTable.FieldName_IsReverse + "=-1,"
                        + pLineNodeExTable.FieldName_IsFromLine + "=1"
                        + " Where " + pLineNodeExTable.TableName_TempTable + "." + pLineNodeExTable.FieldName_LineNodeID + "=" + pMatchLineNodeTable.TableName_TempTable + "." + pMatchLineNodeTable.FieldName_LineExIndexID;
                    pLineNodeExTable.ExecuteNonQuery(strCommand);

                    bNeedSave = false;
                    pMatchLineNodeTable = new MatchLineNodeTable(m_pOleDbConnection, true, false);
                }

                //反向
                strLineNodeExOrderBy = pLineNodeExTable.FieldName_X2 + ","
                    + pLineNodeExTable.FieldName_Y2 + ","
                    + pLineNodeExTable.FieldName_X1 + ","
                    + pLineNodeExTable.FieldName_Y1 + ","
                    + pLineNodeExTable.FieldName_EntityID;

                //必须是未找到标识码的
                strLineNodeExWhere = pLineNodeExTable.FieldName_EntityID + "=-1";
                dataTableLineNodeEx = pLineNodeExTable.GetRecords(strLineNodeExWhere, "", strLineNodeExOrderBy);
                dataTableLineNode = pLineNodeTable.GetRecords(strLineNodeWhere, "", strLineNodeOrderBy);

                j = 0;
                while (dataTableLineNode.Rows.Count > 0)
                {
                    for (i = 0; i < dataTableLineNode.Rows.Count; i++)
                    {
                        if (j == dataTableLineNodeEx.Rows.Count)
                            break;

                        LineNodeSimple lineNode = new LineNodeSimple();
                        pLineNodeTable.GetLineNodeByDataRow(dataTableLineNode.Rows[i], ref lineNode, false);
                        while (dataTableLineNodeEx.Rows.Count > 0)
                        {

                            for (; j < dataTableLineNodeEx.Rows.Count; j++)
                            {
                                LineNodeSimple lineNodeEx = new LineNodeSimple();
                                pLineNodeExTable.GetLineNodeByDataRow(dataTableLineNodeEx.Rows[j], ref lineNodeEx, true);

                                if (lineNodeEx.EntityID != -1)
                                    continue;

                                if (lineNode == lineNodeEx)
                                {
                                    pMatchLineNodeTable.AddRow(lineNode.IndexID, lineNodeEx.IndexID, lineNode.EntityID);
                                    n++;
                                    //pLineNodeExTable.SetLineNodeEntityID(dataTableLineNodeEx.Rows[j], lineNode.EntityID, true);
                                    //if (bNeedSave == false)
                                    //    bNeedSave = true;
                                }
                                else if (lineNode > lineNodeEx)
                                {

                                }
                                else
                                {
                                    break;
                                }

                            }

                            if (j == dataTableLineNodeEx.Rows.Count)
                            {
                                //if (bNeedSave == true)
                                //{
                                //    pLineNodeExTable.Save(false);
                                //}
                                if (dataTableLineNodeEx.Rows.Count < pLineNodeExTable.MaxRecordCount)
                                    break;
                                //else
                                //    bNeedSave = false;
                                dataTableLineNodeEx = pLineNodeExTable.GetNextRecords();
                                j = 0;
                            }
                            else
                                break;
                        }
                    }

                    if (n >= pMatchLineNodeTable.MaxRecordCount)
                    {
                        bNeedSave = true;
                        pMatchLineNodeTable.Save(true);
                        n = 0;
                    }

                    if (i == dataTableLineNode.Rows.Count)
                    {
                        if (dataTableLineNode.Rows.Count < pLineNodeTable.MaxRecordCount)
                            break;
                        dataTableLineNode = pLineNodeTable.GetNextRecords();
                    }
                    else
                        break;
                }
                if (n > 0)
                {
                    bNeedSave = true;
                    pMatchLineNodeTable.Save(true);
                }

                if (bNeedSave == true)
                {
                    string strCommand = "Update " + pLineNodeExTable.TableName_TempTable + "," + pMatchLineNodeTable.TableName_TempTable + " Set "
                        + pLineNodeExTable.TableName_TempTable + "." + pLineNodeExTable.FieldName_EntityID + "=" + pMatchLineNodeTable.TableName_TempTable + "." + pMatchLineNodeTable.FieldName_EntityID + ","
                        + pLineNodeExTable.FieldName_IsReverse + "=1,"
                        + pLineNodeExTable.FieldName_IsFromLine + "=1"
                        + " Where " + pLineNodeExTable.TableName_TempTable + "." + pLineNodeExTable.FieldName_LineNodeID + "=" + pMatchLineNodeTable.TableName_TempTable + "." + pMatchLineNodeTable.FieldName_LineExIndexID;
                    pLineNodeExTable.ExecuteNonQuery(strCommand);
                }
                /*
                 * 匹配条件不正确,FieldName_EntityID重复
                //更新成对索引
                strCommand = "Update " + pLineNodeExTable.TableName_TempTable + " As a," + pLineNodeExTable.TableName_TempTable + " As b Set a."
                    + pLineNodeExTable.FieldName_OrtherLineNodeID + "=b." + pLineNodeExTable.FieldName_LineNodeID
                    //+ ",b." + pLineNodeExTable.FieldName_OrtherLineNodeID + "=a." + pLineNodeExTable.FieldName_LineNodeID
                    + " Where a." + pLineNodeExTable.FieldName_EntityID + ">0 And a." + pLineNodeExTable.FieldName_EntityID + "=b." + pLineNodeExTable.FieldName_EntityID;
                pLineNodeExTable.ExecuteNonQuery(strCommand);
                 * */
            }
        }