public static double CalculateMedianPerplexity(ILayer layer, List<DataSequence> sequences)
        {
            double temperature = 1.0;
            List<Double> ppls = new List<Double>();
            foreach (DataSequence seq in sequences) {
            double n = 0;
            double neglog2Ppl = 0;

            Graph g = new Graph(false);
            layer.ResetState();
            foreach (DataStep step in seq.Steps) {
                Matrix logprobs = layer.Activate(step.Input, g);
                Matrix probs = GetSoftmaxProbs(logprobs, temperature);
                int targetIndex = GetTargetIndex(step.TargetOutput);
                double probOfCorrect = probs.W[targetIndex];
                double log2Prob = Math.Log(probOfCorrect)/Math.Log(2); //change-of-base
                neglog2Ppl += -log2Prob;
                n += 1;
            }

            n -= 1; //don't count first symbol of sentence
            double ppl = Math.Pow(2, (neglog2Ppl/(n-1)));
            ppls.Add(ppl);
            }
            return Util.Util.Median(ppls);
        }
 public FormSymbology(ILegendClass tempLegendClass, ILayer tempLayer)
 {
     InitializeComponent();
     //this.ControlBox = false;   // 设置不出现关闭按钮
     pLegendClass = tempLegendClass;  //通过点击 toccontrol 时候可以获得要素类的 LegendClass!
     pLayer = tempLayer;  //点击的图层
 }
Exemple #3
0
 void LayersLayerRemoved(ILayer layer)
 {
     layer.AbortFetch();
     layer.DataChanged -= AsyncLayerDataChanged;
     layer.Feedback -= LayerFeedback;
     layer.PropertyChanged -= LayerPropertyChanged;
 }
 /// <summary>
 /// Construct the depth calculation object.
 /// </summary>
 /// <param name="network">The network that we are calculating for.</param>
 public CalculateDepth(BasicNetwork network)
 {
     this.network = network;
     this.outputLayer = network.GetLayer(BasicNetwork.TAG_OUTPUT);
     if( this.outputLayer!=null )
         Calculate(0, this.outputLayer);
 }
Exemple #5
0
 void LayersLayerAdded(ILayer layer)
 {
     layer.DataChanged += AsyncLayerDataChanged;
     layer.Feedback += LayerFeedback;
     layer.PropertyChanged += LayerPropertyChanged;
     layer.Transformation = Transformation;
 }
Exemple #6
0
 private string[] GetUnByDataStatistics(ILayer layer, String strField)
 {
     IFeatureLayer featureLayer = layer as IFeatureLayer;
     ILayerFields pLayerFields = featureLayer as ILayerFields;
     int nCount=pLayerFields.FieldCount;
     IQueryFilter queryFilter = new QueryFilterClass();
     queryFilter.SubFields = strField;
     IFeatureCursor featureCursor = featureLayer.FeatureClass.Search(queryFilter, true);
     IDataStatistics dataStatistics = new DataStatisticsClass();
     dataStatistics.Field = strField;
     dataStatistics.Cursor = featureCursor as ICursor;
     System.Collections.IEnumerator pEnumvar = dataStatistics.UniqueValues;
     int number = dataStatistics.UniqueValueCount;
     pEnumvar.Reset();
     object obj = null;
     pEnumvar.MoveNext();
     int i = 0;
     string[] str = new string[nCount];
     while (pEnumvar.MoveNext())
     {
         obj = pEnumvar.Current;
         str[i++] = obj.ToString();
     }
     return str;
 }
        private void AddContextMenuItems(ILayer addedLayer)
        {
            IMapGroup grp = addedLayer as IMapGroup;
            if (grp != null)
            {
                // map.layerAdded event doesn't fire for groups. Therefore, it's necessary
                // to handle this event separately for groups.
                grp.LayerAdded += Map_LayerAdded;
            }

            if (addedLayer.ContextMenuItems.Exists(item => item.Name == contextMenuItemName))
            {
                // assume menu item already exists. Do nothing.
                return;
            }

            // add context menu item.
            var menuItem = new SymbologyMenuItem(contextMenuItemName, delegate { ShowAttributes(addedLayer as IFeatureLayer); });
            menuItem.Image = Resources.table_16x16;
            var cmi = addedLayer.ContextMenuItems;
            if (cmi.Count > 2)
            {
                addedLayer.ContextMenuItems.Insert(2, menuItem);
            }
            else
            {
                addedLayer.ContextMenuItems.Add(menuItem);
            }
       }
        public void InsertLayer(ILayer layer, int index)
        {
            Layers.Insert(index, layer);
            layerCollection.Insert(index + 1, layer);

            OnLayersChanged(EventArgs.Empty);
        }
        public override SpinResolved_Data Get_ChargeDensity_Deriv(ILayer[] layers, SpinResolved_Data carrier_density_deriv, SpinResolved_Data dopent_density_deriv, Band_Data chem_pot)
        {
            for (int i = 0; i < nz; i++)
            {
                double z = dz * i + zmin;

                // get the relevant layer and if it's frozen out, don't recalculate the dopent charge
                ILayer current_Layer = Solver_Bases.Geometry.Geom_Tool.GetLayer(layers, z);

                ZeroD_Density charge_calc = new ZeroD_Density(current_Layer, temperature);
                if (!current_Layer.Dopents_Frozen_Out(temperature))
                {
                    double local_dopent_density_deriv = charge_calc.Get_DopentDensityDeriv(chem_pot.vec[i]);
                    dopent_density_deriv.Spin_Up.vec[i] = 0.5 * local_dopent_density_deriv;
                    dopent_density_deriv.Spin_Down.vec[i] = 0.5 * local_dopent_density_deriv;
                }
                else
                {
                    dopent_density_deriv.Spin_Up.vec[i] = 0.0;
                    dopent_density_deriv.Spin_Down.vec[i] = 0.0;
                }

                carrier_density_deriv.Spin_Up.vec[i] = 0.5 * charge_calc.Get_CarrierDensityDeriv(chem_pot.vec[i]);
                carrier_density_deriv.Spin_Down.vec[i] = 0.5 * charge_calc.Get_CarrierDensityDeriv(chem_pot.vec[i]);
            }

            return carrier_density_deriv + dopent_density_deriv;
        }
Exemple #10
0
        /// <summary>
        /// Overloaded Constructor method
        /// </summary>
        /// <param name="iLayer"> Argument is passed by reference for layer file selected</param>
        public AttributeTable(ILayer iLayer)
        {
            InitializeComponent();

            //intialize variables
            m_iLayer = iLayer;
        }
		private static string RenderFeaturesForLayer(IViewport viewport, ILayer layer)
		{
			if (layer.Enabled == false) return null;

			/*
			if (layer is BasicLayer) {
				var renderedFeatures = SymbolRenderer.RenderStackedLabelLayer (viewport, layer as BasicLayer);

				if (renderedFeatures != null && renderedFeatures.Count > 0){
					renderQueue.PutLayer (layer.Name, renderedFeatures);
					return layer.Name;
				}
			}
			else*/ if (layer is LabelLayer) {
				var renderedFeatures = LabelRenderer.RenderStackedLabelLayer (viewport, layer as LabelLayer);

				if (renderedFeatures != null && renderedFeatures.Count > 0){
					renderQueue.PutLayer (layer.Name, renderedFeatures);
					return layer.Name;
				}
			} else {
				var renderedFeatures = RenderVectorLayerFeatures (viewport, layer);// new List<CALayer> ();

				if (renderedFeatures != null && renderedFeatures.Count > 0){
					//renderQueue.PutLayer (layer.Name, renderedFeatures);
					_featuresForLayer.Add(layer.Name, renderedFeatures);
					return layer.Name;
				}
			}

			return null;
		}
Exemple #12
0
        public void SetUp()
        {
            threadingPolicy = new SingleThreadingPolicy();
            transactionFactory = new TransactionFactory(threadingPolicy);

            layer = MockRepository.GenerateMock<ILayer>();

            serverManager = MockRepository.GenerateMock<IServerManager>();

            serverManagerFactory = MockRepository.GenerateMock<IServerManagerFactory>();

            operationFactory = new OperationFactory(layer, serverManagerFactory);

            sut = new Deployer(transactionFactory, operationFactory);

            project = new Project
            {
                Name = "Search.API",
                Source = @"\\ystage01.ywebfarm.lcl\e$\ServiceArtifacts\Yoox.API\Search.API\1.1_new",
                Path = @"Test\Yoox.API\Search.API\1.0",
                Application = "Search.API",
                Site = "Yoox.API",
                Servers = new[] { @"\\serverA\", @"\\serverB\" },
            };
        }
        public OpenAttributeTable(ILayer pLayer)
        {
            //
            // TODO: Define values for the public properties
            //
            base.m_category = ""; //localizable text
            base.m_caption = "打开属性表";  //localizable text
            base.m_message = "打开属性表";  //localizable text
            base.m_toolTip = "打开属性表";  //localizable text
            base.m_name = "打开属性表";   //unique id, non-localizable (e.g. "MyCategory_MyCommand")
            m_pLayer = pLayer;

            try
            {
            //
            // TODO: change bitmap name if necessary
            //
            string bitmapResourceName = GetType().Name + ".bmp";
            base.m_bitmap = new Bitmap(GetType(), bitmapResourceName);
            }
            catch (Exception ex)
            {
            System.Diagnostics.Trace.WriteLine(ex.Message, "Invalid Bitmap");
            }
        }
Exemple #14
0
        public virtual IFeatureInteractor CreateInteractor(ILayer layer, IFeature feature)
        {
            if (null == feature)
                return null;

            var vectorLayer = layer as VectorLayer;
            var vectorStyle = (vectorLayer != null ? vectorLayer.Style : null);

            // most specific type should be first
            if (feature is RegularGridCoverageCell)
                return new LineStringInteractor(layer, feature, vectorStyle, null);

            if (feature is IGridFace || feature is IGridVertex)
                return new LineStringInteractor(layer, feature, vectorStyle, null);
            
            if (feature.Geometry is ILineString)
                return new LineStringInteractor(layer, feature, vectorStyle, null);
            
            if (feature.Geometry is IPoint)
                return new PointInteractor(layer, feature, vectorStyle, null);
            
            // todo implement custom mutator for Polygon and MultiPolygon
            // LineStringMutator will work as long as moving is not supported.
            if (feature.Geometry is IPolygon)
                return new LineStringInteractor(layer, feature, vectorStyle, null);
            
            if (feature.Geometry is IMultiPolygon)
                return new LineStringInteractor(layer, feature, vectorStyle, null);
            
            return null;
            //throw new ArgumentException("Unsupported type " + feature.Geometry);
        }
        //public Network(double[][] inputValues, double[] desiredOutput, int numberOfLayers, int[] numberOfNeuronsInLayers)
        public Network(int inputWidth, int numberOfLayers, int[] numberOfNeuronsInLayers)
        {
            //_input = inputValues;
            //_desiredOutput = desiredOutput;

            _inputWidth = inputWidth;
            _numberOfLayers = numberOfLayers;

            Layers = new ILayer[_numberOfLayers + 2]; // nie liczymy warstwy wejściowej i wyjściowej

            //najpierw warstwa wejciowa
            Layers[0] = new InputLayer(_inputWidth, _inputWidth);
            //Layers[0] = new InputLayer();

            for (int i = 1; i < numberOfLayers+1; i++)
            {
                Layers[i] = new Layer(numberOfNeuronsInLayers[i - 1], Layers[i - 1].Neurons.Length);
            }

            //warstwa wyjściowa co ma tylko 1 neuron
            Layers[numberOfLayers+1] = new Layer(1, Layers[numberOfLayers].Neurons.Length);

            _totalNumberOfWeights = 0;
            foreach (var layer in Layers)
            {
                _totalNumberOfWeights += layer.NumberOfWeights();
            }
        }
        public LayerControlOnOff(ILayer layer, bool _on)
        {
            InitializeComponent();
            on = _on;

            if (!on)
            {
                this.SItext.Opacity = 0;
                this.NOtext.Opacity = 1;
                this.SliderCircleTranslateTransform.X = -27;
                this.OnOffButton.Background = new SolidColorBrush(Color.FromArgb(255, 31, 31, 31));
            }

            this.layer = layer;

            if (layer is HexagonLayer)
            {
                this.Title.Text = Labels.Layers13;
                ToolTipService.SetToolTip(this.SwitchGrid, Labels.layers15);
            }
            else if (layer is ArgentineLawLayer)
            {
                this.Title.Text = Labels.Layers14;
                ToolTipService.SetToolTip(this.SwitchGrid, Labels.layers16);
            }
            else if (layer is BasecampLayer)
            {
                this.Title.Text = Labels.Layers17;
                ToolTipService.SetToolTip(this.SwitchGrid, Labels.Layers18);
            }
        }
Exemple #17
0
        public virtual IFeature AddNewFeatureByGeometry(ILayer layer, IGeometry geometry)
        {
            if (CreateNewFeature != null)
            {
                var feature = CreateNewFeature(layer);
                feature.Geometry = geometry;
                AddFeatureToDataSource(layer, feature);
                return feature;
            }

            if(addingNewFeature)
            {
                throw new InvalidOperationException("loop detected, something is wrong with your feature provider (check AddNewFeatureFromGeometryDelegate)");
            }

            addingNewFeature = true;
            IFeature newFeature = null;

            try
            {
                newFeature = (IFeature)Activator.CreateInstance(layer.DataSource.FeatureType);
                newFeature.Geometry = geometry;
                AddFeatureToDataSource(layer, newFeature);
            }
            finally
            {
                addingNewFeature = false;
            }

            return newFeature;
        }
        public void CalculateNonVariableLayers()
        {
            CalculateChildren();

            if (!Double.IsNaN(baseOfPower.Calculate(null))) baseOfPower = new NumberLayer(baseOfPower.Calculate(null));
            if (!Double.IsNaN(exponent.Calculate(null))) exponent = new NumberLayer(exponent.Calculate(null));
        }
        private static void IterateLayer(IViewport viewport, ILayer layer,
            Action<IViewport, IStyle, IFeature> callback)
        {
            var features = layer.GetFeaturesInView(viewport.Extent, viewport.RenderResolution).ToList();

            var layerStyles = layer.Style is StyleCollection ? (layer.Style as StyleCollection).ToArray() : new [] {layer.Style};
            foreach (var layerStyle in layerStyles)
            {
                var style = layerStyle; // This is the default that could be overridden by an IThemeStyle

                foreach (var feature in features)
                {
                    if (layerStyle is IThemeStyle) style = (layerStyle as IThemeStyle).GetStyle(feature);
                    if ((style == null) || (style.Enabled == false) || (style.MinVisible > viewport.RenderResolution) || (style.MaxVisible < viewport.RenderResolution)) continue;

                    callback(viewport, style, feature);
                }
            }

            foreach (var feature in features)
            {
                var featureStyles = feature.Styles ?? Enumerable.Empty<IStyle>();
                foreach (var featureStyle in featureStyles)
                {
                    if (feature.Styles != null && featureStyle.Enabled)
                    {
                        callback(viewport, featureStyle, feature);
                    }
                }
            }
        }
Exemple #20
0
        ///// <summary>
        ///// snapping specific for a tool. Called before layer specific snappping is applied.
        ///// </summary>
        ///// <param name="sourceLayer"></param>
        ///// <param name="snapSource"></param>
        ///// <param name="worldPos"></param>
        ///// <param name="Envelope"></param>
        ///// <returns></returns>
        public void Snap(ILayer sourceLayer, IGeometry snapSource, ICoordinate worldPos, IEnvelope Envelope)
        {
            SnapResult = null;
            IFeature sourceFeature = MapControl.SelectTool.FeatureEditors[0].SourceFeature;
            if (sourceFeature.Geometry != snapSource)
                return;
            SnapRole snapRole = SnapRole.FreeAtObject;
            if ((Control.ModifierKeys & Keys.Control) == Keys.Control)
                snapRole = SnapRole.Free;
            ISnapRule snapRule = new SnapRule
                                     {
                                         SourceLayer = sourceLayer,
                                         TargetLayer = sourceLayer,
                                         Obligatory = true,
                                         SnapRole = snapRole,
                                         PixelGravity = 4
                                     };

            SnapResult = MapControl.SnapTool.ExecuteSnapRule(
                                                snapRule,
                                                sourceFeature,
                                                sourceFeature.Geometry,
                                                new List<IFeature>
                                                    {
                                                        sourceFeature
                                                    },
                                                worldPos,
                                                -1);
        }
Exemple #21
0
 /// <summary>
 /// Creates a new instance of LayerDialog form to display the symbology and
 /// other properties of the specified feature layer
 /// </summary>
 /// <param name="selectedLayer">the specified feature layer that is
 /// modified using this form</param>
 /// <param name="control">The control.</param>
 public LayerDialog(ILayer selectedLayer, ICategoryControl control)
     : this()
 {
     _layer = selectedLayer;
     propertyGrid1.SelectedObject = _layer;
     Configure(control);
 }
Exemple #22
0
 protected override void OnClick()
 {
     // var mun = default(List);
     try{
         B.limpiarLayerTmp(ArcMap.Document);
         System.Windows.Forms.Cursor.Current = System.Windows.Forms.Cursors.WaitCursor;
         select_area = B.returnLayerByName(ArcMap.Document,globales.nomlayerSELECT);
         MUNICIPIOS = B.returnLayerByName(ArcMap.Document, globales.nomlayerMUNICIPIOS);
         G.selectLayerByLocation(MUNICIPIOS, select_area, "INTERSECT");
         G.copyFeatures(MUNICIPIOS, globales.gdb + "municipioszv");
         mun = B.listadeValores(ArcMap.Document, "municipioszv", "municipio");
         foreach (var element in mun)
                 insertaMunicipio(element);
         System.Windows.Forms.Cursor.Current = System.Windows.Forms.Cursors.Default;
         B.limpiarZonasTmp(ArcMap.Document, "municipio");
         B.limpiarZonasTmp(ArcMap.Document, "municipioszv");
         B.limpiarLayerTmp(ArcMap.Document);
         MessageBox.Show("Proceso terminado");
         pMxDoc.ActiveView.Refresh();
     }catch (Exception ex) {
         MessageBox.Show("Error: " + ex.Message, "btnMunicipioAreas");
         MessageBox.Show("Error: " + ex.StackTrace);
         return;
     }
 }
        public void Parse()
        {
            PreParsing();
            DeleteSurroundingBrackets();

            Type topLayerType = GetTopLayerType();

            if (topLayerType == typeof(NumberLayer))
                topLayer = ParseNumberLayerFromElement();

            if (topLayerType == typeof(VariableLayer))
                topLayer = ParseVariableLayerFromElement();

            if (topLayerType == typeof(AddSubtractLayer))
                topLayer = ParseAddSubtractLayerFromElements();

            if (topLayerType == typeof(MultiplyDivideLayer))
                topLayer = ParseMultiplyDivideLayerFromElements();

            if (topLayerType == typeof(RootLayer))
                topLayer = ParseRootLayerFromElements();

            if (topLayerType == typeof(PowerLayer))
                topLayer = ParsePowerLayerFromElements();

            if (topLayerType == typeof(LogarithmLayer))
                topLayer = ParseLogarithmLayerFromElements();
        }
        public override bool Render(IFeature feature, Graphics g, ILayer layer)
        {
            var segmentsLayer = (NetworkCoverageSegmentLayer) layer;
            var coverage = ((NetworkCoverageFeatureCollection)layer.DataSource).RenderedCoverage;
            IEnvelope mapExtents = layer.Map.Envelope;
            
            var sliceValues = coverage.GetValues();

            // 1 find the segments withing the current extend
            var segments = coverage.Segments.Values;//.Where(seg => seg.Geometry.EnvelopeInternal.Intersects(mapExtents)).ToList();

            for (int i = 0; i < segments.Count; i++)
            {
                INetworkSegment segment = segments[i];
                if (segment.Geometry.EnvelopeInternal.Intersects(mapExtents) && sliceValues.Count > 0)
                {
                    // 2 get the values for this segment
                    // if SegmentGenerationMethod == SegmentGenerationMethod.RouteBetweenLocations the segments and 
                    // location do not have to match; return default value
                    double value = coverage.SegmentGenerationMethod == SegmentGenerationMethod.RouteBetweenLocations
                                       ? 0
                                       : (double) sliceValues[i];

                    // 3 use the Theme of the layer to draw 
                    var style = (VectorStyle)segmentsLayer.Theme.GetStyle(value);
                    VectorRenderingHelper.RenderGeometry(g, layer.Map, segment.Geometry, style, null, true);
                }
            }
            return true;
        }
 //Why ask the renderer when you know already?
 public override IList GetFeatures(IEnvelope box, ILayer layer)
 {
     var coverage = ((NetworkCoverageSegmentLayer)layer).Coverage;
     var segments = coverage.Segments.Values
         .Where(networkLocation => networkLocation.Geometry.EnvelopeInternal.Intersects(box)).ToList();
     return segments;
 }
        public KohonenLearning(ILayer layer)
        {
            int neuronsCount = layer.Neurons.Count;
            this._width = (int) Math.Sqrt( neuronsCount );

            this._layer	= layer;
        }
Exemple #27
0
 private void SetDataSource(IDataSource dataSource, ILayer layer)
 {
     this.Clear();
     this.activeDataSources.Add(dataSource);
     this.videoControl.AddLayer(layer);
     dataSource.Start();
 }
Exemple #28
0
        /// <summary>
        /// ����¼�
        /// </summary>
        public override void OnClick()
        {
            DataEditCommon.InitEditEnvironment();
            DataEditCommon.CheckEditState();

            m_pCurrentLayer = DataEditCommon.GetLayerByName(DataEditCommon.g_pMap,LayerNames.LAYER_ALIAS_MR_XianLuoZhu1);
            IFeatureLayer featureLayer = m_pCurrentLayer as IFeatureLayer;
            if (featureLayer == null)
            {
                MessageBox.Show(@"������ͼ�㶪ʧ��", "��ʾ", MessageBoxButtons.OK, MessageBoxIcon.Information);
                DataEditCommon.g_pMyMapCtrl.CurrentTool = null;
                return;
            }
            else
            {
                if (featureLayer.FeatureClass.ShapeType != esriGeometryType.esriGeometryPolygon)
                {
                    MessageBox.Show(@"������ͼ�㶪ʧ��", "��ʾ", MessageBoxButtons.OK, MessageBoxIcon.Information);
                    DataEditCommon.g_pMyMapCtrl.CurrentTool = null;
                    return;
                }
            }

            m_pMap = m_hookHelper.FocusMap;
        }
        /// <summary>
        /// Called internally to calculate a depth. 
        /// </summary>
        /// <param name="currentDepth">The current depth.</param>
        /// <param name="layer">The layer we are on.</param>
        private void Calculate(int currentDepth, ILayer layer)
        {

            // record this layer
            if (this.depths.ContainsKey(layer))
            {
                int oldDepth = this.depths[layer];
                if (currentDepth > oldDepth)
                {
                    this.depths[layer] = currentDepth;
                }
            }
            else
            {
                this.depths[layer] = currentDepth;
            }

            // traverse all of the ways to get to that layer
            ICollection<ILayer> prev = this.network.Structure
                    .GetPreviousLayers(layer);

            foreach (ILayer nextLayer in prev)
            {
                if (!this.depths.ContainsKey(nextLayer))
                {
                    Calculate(currentDepth + 1, nextLayer);
                }
            }
        }
Exemple #30
0
 public ModifyShape(ILayer pCurrentLayer)
 {
     //
     // TODO: Define values for the public properties
     //
     m_CurrentLayer = pCurrentLayer;
 }
Exemple #31
0
        private void btnup_Click(object sender, EventArgs e)
        {
            //设置一个最小值
            progressBarControl1.Properties.Minimum = 0;

            //设置步长,即每次增加的数
            progressBarControl1.Properties.Step = 1;
            //设置进度条的样式
            progressBarControl1.Properties.ProgressViewStyle = DevExpress.XtraEditors.Controls.ProgressViewStyle.Solid;
            progressBarControl1.Position = 0;

            //设置一个最小值
            progressBarControl2.Properties.Minimum = 0;
            //设置一个最大值
            progressBarControl2.Properties.Maximum = listView1.CheckedItems.Count * 2;
            //设置步长,即每次增加的数
            progressBarControl2.Properties.Step = 1;
            //设置进度条的样式
            progressBarControl2.Properties.ProgressViewStyle = DevExpress.XtraEditors.Controls.ProgressViewStyle.Solid;
            progressBarControl2.Position = 0;

            ////设置一个最小值
            //progressBar2.Minimum = 0;
            ////设置一个最大值
            //progressBar2.Maximum = listView1.CheckedItems.Count * 2;
            ////设置步长,即每次增加的数
            //progressBar2.Step = 1;
            //progressBar2.Value = 0;


            IFeatureClass tFeatureClass = pFeatureLayer_QYYJY.FeatureClass;

            DataEditCommon.DeleteFeatureByWhereClause(tFeatureClass, "");
            IGeometryArray pgeoArrayHong = new GeometryArrayClass();
            IGeometryArray pgeoArrayHang = new GeometryArrayClass();

            for (int i = 0; i < listView1.CheckedItems.Count; i++)
            {
                string        layer         = listView1.CheckedItems[i].SubItems[1].Text.ToString();
                ILayer        pLayer        = DataEditCommon.GetLayerByName(DataEditCommon.g_pMap, layer);
                IFeatureLayer pFeatureLayer = pLayer as IFeatureLayer;
                if (pFeatureLayer == null)
                {
                    continue;
                }
                IFeatureClass pFeatureClass = pFeatureLayer.FeatureClass;
                //设置一个最大值
                progressBarControl1.Properties.Maximum = pFeatureClass.FeatureCount(null);
                IFeatureCursor pCursor  = pFeatureClass.Search(null, false);
                IFeature       pFeature = pCursor.NextFeature();

                while (pFeature != null)
                {
                    ITopologicalOperator pTopo = (ITopologicalOperator)pFeature.Shape;
                    IGeometry            pGeo  = pTopo.Buffer(hongse);
                    pgeoArrayHong.Add(pGeo);
                    IGeometry pGeoH = pTopo.Buffer(huangse);
                    if (pFeatureClass.ShapeType == esriGeometryType.esriGeometryPolygon)
                    {
                        pTopo = (ITopologicalOperator)pGeoH;
                        pGeoH = pTopo.Difference(pGeo);
                    }
                    pgeoArrayHang.Add(pGeoH);
                    pFeature = pCursor.NextFeature();
                    this.progressBarControl1.PerformStep();
                    Application.DoEvents();
                }
                List <ziduan> list = new List <ziduan>();
                list.Add(new ziduan("dengji", "1"));
                list.Add(new ziduan("layername", layer));
                list.Add(new ziduan("BID", "0"));
                DataEditCommon.CreateFeature(tFeatureClass, pgeoArrayHong, list);
                this.progressBarControl2.PerformStep();
                //progressBar2.Value += 1;
                Application.DoEvents();
                List <ziduan> listH = new List <ziduan>();
                listH.Add(new ziduan("dengji", "2"));
                listH.Add(new ziduan("layername", layer));
                listH.Add(new ziduan("BID", "0"));
                DataEditCommon.CreateFeature(tFeatureClass, pgeoArrayHang, listH);
                this.progressBarControl2.PerformStep();
                //progressBar2.Value += 1;
                Application.DoEvents();
            }
            if (pFeatureLayer_QYYJY.Visible == false)
            {
                pFeatureLayer_QYYJY.Visible = true;
            }
            DataEditCommon.g_pMyMapCtrl.ActiveView.PartialRefresh(esriViewDrawPhase.esriViewGeography, null, null);
            MessageBox.Show("完成!");
        }
Exemple #32
0
 public GridProfileEditor(ICoordinateConverter coordinateConverter, ILayer layer, IFeature feature, VectorStyle vectorStyle)
     : base(coordinateConverter, layer, feature, vectorStyle)
 {
 }
 /// <summary>
 /// Method called when <paramref name="layer"/> has been rendered. This fires the
 /// <see cref="LayerRendered"/> and <see cref="E:SharpMap.Map.LayerRenderedEx"/> event.
 /// </summary>
 /// <param name="layer">The layer to render</param>
 protected virtual void OnLayerRendered(ILayer layer)
 {
     Logger.Debug("OnLayerRendered");
     LayerRendered?.Invoke(this, new LayerRenderingEventArgs(layer));
 }
Exemple #34
0
        public bool Open()
        {
            try
            {
                _elements.Clear();
                string param = "REQUEST=GetCapabilities&VERSION=1.0.0&SERVICE=WFS";

                string url      = WMSDataset.Append2Url(_url, param);
                string response = WebFunctions.HttpSendRequest(url, "GET", null);
                response = WMSDataset.RemoveDOCTYPE(response);

                XmlDocument doc = new XmlDocument();
                doc.LoadXml(response);
                XmlNamespaceManager ns = new XmlNamespaceManager(doc.NameTable);
                ns.AddNamespace("WFS", "http://www.opengis.net/wfs");
                ns.AddNamespace("OGC", "http://www.opengis.net/ogc");
                ns.AddNamespace("GML", "http://www.opengis.net/gml");

                XmlNode CapabilitiesNode = doc.SelectSingleNode("WFS:WFS_Capabilities/WFS:Capability", ns);
                _getCapabilities    = new GetCapabilities(CapabilitiesNode.SelectSingleNode("WFS:Request/WFS:GetCapabilities", ns), ns);
                _decribeFeatureType = new DescribeFeatureType(CapabilitiesNode.SelectSingleNode("WFS:Request/WFS:DescribeFeatureType", ns), ns);
                _getFeature         = new GetFeature(CapabilitiesNode.SelectSingleNode("WFS:Request/WFS:GetFeature", ns), ns);

                XmlNode FeatureTypeListNode = doc.SelectSingleNode("WFS:WFS_Capabilities/WFS:FeatureTypeList", ns);
                _operations = new Operations(FeatureTypeListNode.SelectSingleNode("WFS:Operations", ns));

                foreach (XmlNode featureTypeNode in FeatureTypeListNode.SelectNodes("WFS:FeatureType", ns))
                {
                    string name  = "";
                    string title = "";

                    XmlNode nameNode  = featureTypeNode.SelectSingleNode("WFS:Name", ns);
                    XmlNode titleNode = featureTypeNode.SelectSingleNode("WFS:Title", ns);

                    WMSClass.SRS srs = new WMSClass.SRS(featureTypeNode, ns, "WFS");

                    name = title = nameNode.InnerText;
                    if (titleNode != null)
                    {
                        title = titleNode.InnerText;
                    }

                    WFSFeatureClass featureClass = new WFSFeatureClass(this, name, srs);
                    //DatasetElement dselement = new DatasetElement(featureClass);
                    ILayer dselement = LayerFactory.Create(featureClass);
                    if (dselement == null)
                    {
                        continue;
                    }
                    dselement.Title = name;

                    _elements.Add(dselement);
                }

                _filter_capabilites = new Filter_Capabilities(doc.SelectSingleNode("WFS:WFS_Capabilities/OGC:Filter_Capabilities", ns), ns);
                return(true);
            }
            catch (Exception ex)
            {
                string err = ex.Message;
                return(false);
            }
        }
Exemple #35
0
        /// <summary>
        /// Here we need to create the lines of sight and determine is a target can be seen or not
        /// Visualize the visible targets with GREEN circles
        /// Visualize the non visible targets with RED circles
        /// Visualize the number of observers that can see a target with a label #
        /// Visualize an observer that can see no targets with a RED circle on top of a BLUE circle
        /// Visualize an observer that can see at least one target with a GREEN circle on top of a BLUE circle
        /// </summary>
        internal override void CreateMapElement()
        {
            try
            {
                IsRunning = true;
                IPolyline longestLine = new PolylineClass();



                ILayer surfaceLayer = GetLayerFromMapByName(ArcMap.Document.FocusMap, SelectedSurfaceName);
                if (surfaceLayer == null)
                {
                    System.Windows.MessageBox.Show(VisibilityLibrary.Properties.Resources.MsgSurfaceLayerNotFound, VisibilityLibrary.Properties.Resources.CaptionError);
                    return;
                }

                IsValidSurface = ValidateElevationSurface();
                if (!IsValidSurface)
                {
                    return;
                }

                // Issue warning if layer is ImageServerLayer
                if (surfaceLayer is IImageServerLayer)
                {
                    MessageBoxResult mbr = MessageBox.Show(VisibilityLibrary.Properties.Resources.MsgLayerIsImageService,
                                                           VisibilityLibrary.Properties.Resources.CaptionLayerIsImageService, MessageBoxButton.YesNo);

                    if (mbr == MessageBoxResult.No)
                    {
                        System.Windows.MessageBox.Show(VisibilityLibrary.Properties.Resources.MsgTryAgain, VisibilityLibrary.Properties.Resources.MsgCalcCancelled);
                        return;
                    }
                }

                // Determine if selected surface is projected or geographic
                var geoDataset = surfaceLayer as IGeoDataset;
                if (geoDataset == null)
                {
                    System.Windows.MessageBox.Show(VisibilityLibrary.Properties.Resources.MsgTryAgain, VisibilityLibrary.Properties.Resources.CaptionError);
                    return;
                }

                SelectedSurfaceSpatialRef = geoDataset.SpatialReference;

                if (SelectedSurfaceSpatialRef is IGeographicCoordinateSystem)
                {
                    MessageBox.Show(VisibilityLibrary.Properties.Resources.LLOSUserPrompt, VisibilityLibrary.Properties.Resources.LLOSUserPromptCaption);
                    return;
                }

                if (ArcMap.Document.FocusMap.SpatialReference.FactoryCode != geoDataset.SpatialReference.FactoryCode)
                {
                    MessageBox.Show(VisibilityLibrary.Properties.Resources.LOSDataFrameMatch, VisibilityLibrary.Properties.Resources.LOSSpatialReferenceCaption);
                    SetErrorTemplate(false);
                    return;
                }

                if (!CanCreateElement || ArcMap.Document == null || ArcMap.Document.FocusMap == null || string.IsNullOrWhiteSpace(SelectedSurfaceName))
                {
                    return;
                }

                SetErrorTemplate(true);
                ReadSelectedLayerPoints();


                if ((LLOS_ObserversInExtent.Any() || ObserverAddInPoints.Any()) &&
                    LLOS_TargetsInExtent.Any() || TargetAddInPoints.Any())
                {
                    // take your observer and target points and get lines of sight
                    var observerPoints = new ObservableCollection <AddInPoint>(LLOS_ObserversInExtent.Select(x => x.AddInPoint).Union(ObserverInExtentPoints));
                    var targetPoints   = new ObservableCollection <AddInPoint>(LLOS_TargetsInExtent.Select(x => x.AddInPoint).Union(TargetInExtentPoints));
                    var surface        = GetSurfaceFromMapByName(ArcMap.Document.FocusMap, SelectedSurfaceName);

                    if (surface == null)
                    {
                        return;
                    }



                    SelectedSurfaceSpatialRef = geoDataset.SpatialReference;

                    var geoBridge = (IGeoDatabaseBridge2) new GeoDatabaseHelperClass();

                    IPoint    pointObstruction = null;
                    IPolyline polyVisible      = null;
                    IPolyline polyInvisible    = null;
                    bool      targetIsVisible  = false;

                    double finalObserverOffset = GetOffsetInZUnits(ObserverOffset.Value, surface.ZFactor, OffsetUnitType);
                    double finalTargetOffset   = GetOffsetInZUnits(TargetOffset.Value, surface.ZFactor, OffsetUnitType);

                    var DictionaryTargetObserverCount = new Dictionary <IPoint, int>();

                    foreach (var observerPoint in observerPoints)
                    {
                        // keep track of visible targets for this observer
                        var CanSeeAtLeastOneTarget = false;

                        var z1 = surface.GetElevation(observerPoint.Point) + finalObserverOffset;

                        if (double.IsNaN(z1))
                        {
                            System.Windows.MessageBox.Show(VisibilityLibrary.Properties.Resources.LLOSPointsOutsideOfSurfaceExtent, VisibilityLibrary.Properties.Resources.MsgCalcCancelled);
                            return;
                        }

                        foreach (var targetPoint in targetPoints)
                        {
                            var z2 = surface.GetElevation(targetPoint.Point) + finalTargetOffset;

                            if (double.IsNaN(z2))
                            {
                                System.Windows.MessageBox.Show(VisibilityLibrary.Properties.Resources.LLOSPointsOutsideOfSurfaceExtent, VisibilityLibrary.Properties.Resources.MsgCalcCancelled);
                                return;
                            }

                            var fromPoint = new PointClass()
                            {
                                Z = z1, X = observerPoint.Point.X, Y = observerPoint.Point.Y, ZAware = true
                            } as IPoint;
                            var toPoint = new PointClass()
                            {
                                Z = z2, X = targetPoint.Point.X, Y = targetPoint.Point.Y, ZAware = true
                            } as IPoint;

                            geoBridge.GetLineOfSight(surface, fromPoint, toPoint,
                                                     out pointObstruction, out polyVisible, out polyInvisible, out targetIsVisible, false, false);

                            var pcol = new PolylineClass() as IPointCollection;
                            pcol.AddPoint(fromPoint);
                            pcol.AddPoint(toPoint);
                            IPolyline pcolPolyline = pcol as IPolyline;

                            longestLine = (longestLine != null && longestLine.Length < pcolPolyline.Length) ? pcolPolyline : longestLine;

                            // set the flag if we can see at least one target
                            if (targetIsVisible)
                            {
                                CanSeeAtLeastOneTarget = true;

                                // update target observer count
                                UpdateTargetObserverCount(DictionaryTargetObserverCount, targetPoint.Point);
                            }

                            // First Add "SightLine" so it appears behind others
                            // Black = Not visible -or- White = Visible
                            if (targetIsVisible)
                            {
                                AddGraphicToMap(pcolPolyline, new RgbColorClass()
                                {
                                    RGB = 0xFFFFFF
                                }, false,
                                                size: 6); //  white line
                            }
                            else
                            {
                                AddGraphicToMap(pcolPolyline, new RgbColorClass()
                                {
                                    RGB = 0x000000
                                }, false,
                                                size: 6); //  black line
                            }
                            if (polyVisible != null)
                            {
                                AddGraphicToMap(polyVisible, new RgbColorClass()
                                {
                                    Green = 255
                                }, size: 5);
                            }

                            if (polyInvisible != null)
                            {
                                AddGraphicToMap(polyInvisible, new RgbColorClass()
                                {
                                    Red = 255
                                }, size: 3);
                            }

                            if (polyVisible == null && polyInvisible == null)
                            {
                                if (targetIsVisible)
                                {
                                    AddGraphicToMap(pcol as IPolyline, new RgbColorClass()
                                    {
                                        Green = 255
                                    }, size: 3);
                                }
                                else
                                {
                                    AddGraphicToMap(pcol as IPolyline, new RgbColorClass()
                                    {
                                        Red = 255
                                    }, size: 3);
                                }
                            }
                        }

                        // visualize observer

                        // add blue dot
                        AddGraphicToMap(observerPoint.Point, new RgbColorClass()
                        {
                            Blue = 255
                        }, size: 10);

                        if (CanSeeAtLeastOneTarget)
                        {
                            // add green dot
                            AddGraphicToMap(observerPoint.Point, new RgbColorClass()
                            {
                                Green = 255
                            });
                        }
                        else
                        {
                            // add red dot
                            AddGraphicToMap(observerPoint.Point, new RgbColorClass()
                            {
                                Red = 255
                            });
                        }
                    }

                    VisualizeTargets(DictionaryTargetObserverCount, targetPoints);

                    if ((ObserverInExtentPoints.Any() || LLOS_ObserversInExtent.Any()) &&
                        (TargetInExtentPoints.Any() || LLOS_TargetsInExtent.Any()))
                    {
                        ZoomToExtent(longestLine);
                    }

                    DisplayOutOfExtentMsg();

                    //display points present out of extent
                    var colorObserver = new RgbColorClass()
                    {
                        Blue = 255
                    };
                    var colorTarget = new RgbColorClass()
                    {
                        Red = 255
                    };
                    var colorObserverBorder = new RgbColorClass()
                    {
                        Red = 255, Blue = 255, Green = 255
                    };
                    var colorTargetBorder = new RgbColorClass()
                    {
                        Red = 0, Blue = 0, Green = 0
                    };
                    var observerOutOfExtent = new ObservableCollection <AddInPoint>(LLOS_ObserversOutOfExtent.Select(x => x.AddInPoint).Union(ObserverOutExtentPoints));
                    foreach (var point in observerOutOfExtent)
                    {
                        AddGraphicToMap(point.Point, colorObserver, markerStyle: esriSimpleMarkerStyle.esriSMSX, size: 10, borderColor: colorObserverBorder);
                    }
                    var targetOutOfExtent = new ObservableCollection <AddInPoint>(LLOS_TargetsOutOfExtent.Select(x => x.AddInPoint).Union(TargetOutExtentPoints));
                    foreach (var point in targetOutOfExtent)
                    {
                        AddGraphicToMap(point.Point, colorTarget, markerStyle: esriSimpleMarkerStyle.esriSMSX, size: 10, borderColor: colorTargetBorder);
                    }
                }
                else
                {
                    System.Windows.MessageBox.Show(VisibilityLibrary.Properties.Resources.OutOfExtentMsg, VisibilityLibrary.Properties.Resources.OutOfExtentHeader);
                }
            }
            catch (Exception ex)
            {
                System.Diagnostics.Debug.WriteLine(ex.Message);
                System.Windows.Forms.MessageBox.Show(VisibilityLibrary.Properties.Resources.ExceptionSomethingWentWrong,
                                                     VisibilityLibrary.Properties.Resources.CaptionError);
            }
            finally
            {
                IsRunning = false;
                ClearLLOSCollections();
                ValidateLLOS_LayerSelection();
            }
        }
Exemple #36
0
 private void LayersLayerRemoved(ILayer layer)
 {
     layer.AbortFetch();
     layer.DataChanged     -= LayerDataChanged;
     layer.PropertyChanged -= LayerPropertyChanged;
 }
Exemple #37
0
 public LayerObject(ILayer ilayer_1)
 {
     this.ilayer_0 = ilayer_1;
 }
Exemple #38
0
        /// <summary>
        /// Occurs when this command is clicked
        /// </summary>
        public override void OnClick()
        {
            // TODO: Add ShortPathSolveCommand.OnClick implementation
            //string name = NetWorkAnalysClass.getPath(path) + "\\data\\HuanbaoGeodatabase.gdb";
            string            name        = NetWorkAnalysClass.getPath(path) + "\\Data\\TestNet.gdb";
            IFeatureWorkspace pFWorkspace = NetWorkAnalysClass.OpenWorkspace(name) as IFeatureWorkspace;

            //"RouteNetwork", "BaseData"参数不可更改
            networkDataset = NetWorkAnalysClass.OpenPathNetworkDataset(pFWorkspace as IWorkspace, "NetWork_wy_ND", "NetWork_wy");
            m_NAContext    = NetWorkAnalysClass.CreatePathSolverContext(networkDataset);
            //通过网络数据集创建网络分析上下文
            //打开要素数据集
            inputFClass   = pFWorkspace.OpenFeatureClass("Stops");
            barriesFClass = pFWorkspace.OpenFeatureClass("Barries");
            if (IfLayerExist("NetworkDataset") == false)
            {
                ILayer        layer;
                INetworkLayer networkLayer;
                networkLayer = new NetworkLayerClass();
                networkLayer.NetworkDataset = networkDataset;
                layer      = networkLayer as ILayer;
                layer.Name = "NetworkDataset";
                m_hookHelper.ActiveView.FocusMap.AddLayer(layer);
                layer.Visible = false;
            }
            if (IfLayerExist(m_NAContext.Solver.DisplayName) == true)
            {
                for (int i = 0; i < m_hookHelper.FocusMap.LayerCount; i++)
                {
                    if (m_hookHelper.FocusMap.get_Layer(i).Name == m_NAContext.Solver.DisplayName)
                    {
                        m_hookHelper.FocusMap.DeleteLayer(m_hookHelper.FocusMap.get_Layer(i));
                    }
                }
            }
            INALayer naLayer = m_NAContext.Solver.CreateLayer(m_NAContext);
            ILayer   pLayer  = naLayer as ILayer;

            pLayer.Name = m_NAContext.Solver.DisplayName;
            m_hookHelper.ActiveView.FocusMap.AddLayer(pLayer);
            if (inputFClass.FeatureCount(null) < 2)
            {
                MessageBox.Show("只有一个站点,不能进行路径分析!");
                return;
            }
            IGPMessages gpMessages = new GPMessagesClass();

            //加载站点要素,并设置容差
            NetWorkAnalysClass.LoadNANetworkLocations("Stops", inputFClass, m_NAContext, 50);
            //加载障碍点要素,并设置容差
            NetWorkAnalysClass.LoadNANetworkLocations("Barriers", barriesFClass, m_NAContext, 5);
            INASolver naSolver = m_NAContext.Solver;//创建网络分析对象

            try
            {
                naSolver.Solve(m_NAContext, gpMessages, null);
            }
            catch (Exception ex)
            {
                MessageBox.Show("未能找到有效路径" + ex.Message, "提示", MessageBoxButtons.OKCancel, MessageBoxIcon.Warning);
                return;
            }
            for (int i = 0; i < m_hookHelper.FocusMap.LayerCount; i++)
            {
                if (m_hookHelper.FocusMap.get_Layer(i).Name == m_NAContext.Solver.DisplayName)
                {
                    ICompositeLayer pCompositeLayer = m_hookHelper.FocusMap.get_Layer(i) as ICompositeLayer;
                    {
                        for (int t = 0; t < pCompositeLayer.Count; t++)
                        {
                            ILayer pResultLayer = pCompositeLayer.get_Layer(t);
                            if (pResultLayer.Name == "Stops" || pResultLayer.Name == "Barriers")
                            {
                                pResultLayer.Visible = false;
                                continue;
                            }
                        }
                    }
                }
            }
            IGeoDataset geoDataset;
            IEnvelope   envelope;

            geoDataset = m_NAContext.NAClasses.get_ItemByName("Routes") as IGeoDataset;
            envelope   = geoDataset.Extent;
            if (!envelope.IsEmpty)
            {
                envelope.Expand(1.1, 1.1, true);
            }
            m_hookHelper.ActiveView.Extent = envelope;
            m_hookHelper.ActiveView.Refresh();
        }
Exemple #39
0
 /// <summary>
 /// This selects the layer with the specified integer index
 /// </summary>
 /// <param name="index">THe zero based integer index</param>
 public void SelectLayer(int index)
 {
     SelectedLayer = this[index];
 }
 /// <summary>
 /// Construct a weighted synapse between the two layers.
 /// </summary>
 /// <param name="fromLayer">The starting layer.</param>
 /// <param name="toLayer">The ending layer.</param>
 public WeightedSynapse(ILayer fromLayer, ILayer toLayer)
 {
     this.FromLayer = fromLayer;
     this.ToLayer   = toLayer;
     this.matrix    = new Matrix(this.FromNeuronCount, this.ToNeuronCount);
 }
        private void check_errors_btn_Click(object sender, EventArgs e)
        {
            ccr = new CheckCenterlineRanges();

            CheckFeaturesProgressBar.Value   = 0;
            CheckFeaturesProgressBar.Visible = true;
            CheckFeaturesProgressBar.Maximum = ccr.NumFeatures;

            error_treeview.Nodes.Clear();

            ccr.ProgressUpdate += new CheckCenterlineRanges.ProcessUpdateHandler(ccr_ProgressUpdate);

            Errors = ccr.Check();



            List <string> streets = new List <string>(Errors.CenterlineChains.Keys);

            errorCountLabel.Text = ccr.NumErrors.ToString();

            string exp = "OBJECTID in (";

            if (Errors.CenterlineChains.Count > 0)
            {
                foreach (KeyValuePair <string, List <Range> > kvp in Errors.CenterlineChains)
                {
                    foreach (Range r in kvp.Value)
                    {
                        if (r.Errors.Count > 0)
                        {
                            exp += r.ID.ToString() + ",";
                        }
                    }
                }
            }
            else
            {
                exp += "-1";
            }

            string exp2 = exp.TrimEnd(',');

            exp  = exp2;
            exp += ")";

            bool AddStreetLayer = true;

            ILayer streetLayer          = null;
            IFeatureLayerDefinition fld = null;

            for (int i = 0; i < ArcMap.Document.FocusMap.LayerCount; i++)
            {
                ILayer l = ArcMap.Document.FocusMap.get_Layer(i);
                if (l.Name == "StreetErrors")
                {
                    AddStreetLayer = false;//ArcMap.Document.FocusMap.DeleteLayer(l);
                    streetLayer    = l;
                }
            }

            if (AddStreetLayer)
            {
                // Attempted to create a layer from the errors......... FAIL

                IFeatureLayer streetErrorsLayer = new FeatureLayerClass();
                streetErrorsLayer.FeatureClass = Globals.CenterlineLayer.FeatureClass;

                //ArcMap.Document.FocusMap.

                streetLayer = (ILayer)streetErrorsLayer;

                fld = (IFeatureLayerDefinition)streetLayer;

                //ILayerDescription ld = (ILayerDescription)streetLayer;
                //ILayerDescription3 layerDesc = (ILayerDescription)ld;


                fld.DefinitionExpression = exp;
                //layerDesc.DefinitionExpression = exp;

                streetLayer.Name = "StreetErrors";



                ArcMap.Document.AddLayer(streetLayer);
            }
            else
            {
                fld = (IFeatureLayerDefinition)streetLayer;
                fld.DefinitionExpression = exp;
            }


            streets.Sort();

            foreach (string str in streets)
            {
                string[] parts = str.Split('-');

                TreeNode treeNode = new TreeNode(parts[0]);
                treeNode.Tag  = "Chain";
                treeNode.Name = str;
                //treeNode.ContextMenuStrip = contextMenuStrip1;
                List <Range> ranges = Errors.CenterlineChains[str];
                foreach (Range r in ranges)
                {
                    if (r.Errors.Count > 0)
                    {
                        TreeNode child = new TreeNode(r.ID.ToString());
                        child.Tag = "Segment";
                        //child.ContextMenuStrip = contextMenuStrip1;

                        foreach (String s in r.Errors)
                        {
                            child.Nodes.Add(s);
                        }

                        treeNode.Nodes.Add(child);
                    }
                }

                if (treeNode.Nodes.Count > 0)
                {
                    error_treeview.Nodes.Add(treeNode);
                }
            }

            CheckFeaturesProgressBar.Visible = false;
        }
Exemple #42
0
 /// <summary>
 /// Fires the LayerSelected event and adjusts the selected state of the layer.
 /// </summary>
 /// <param name="layer">The layer to select</param>
 /// <param name="selected">Boolean, true if the specified layer is selected</param>
 protected virtual void OnLayerSelected(ILayer layer, bool selected)
 {
     LayerSelected?.Invoke(this, new LayerSelectedEventArgs(layer, selected));
 }
Exemple #43
0
        public override void OnClick()
        {
            ILayer layer = (ILayer)m_mapControl.CustomProperty;

            m_mapControl.Map.DeleteLayer(layer);
        }
Exemple #44
0
        /// <summary>
        /// Checks the Mouse Up event to see if it occurs inside a legend item.
        /// </summary>
        /// <param name="e"></param>
        protected override void OnMouseUp(MouseEventArgs e)
        {
            Point loc = new Point(e.X + ControlRectangle.X, e.Location.Y + ControlRectangle.Top);

            if (!_wasDoubleClick)
            {
                foreach (LegendBox box in _legendBoxes)
                {
                    if (!box.Bounds.Contains(loc))
                    {
                        continue;
                    }
                    ItemMouseEventArgs args = new ItemMouseEventArgs(e, box);
                    DoItemMouseUp(args);
                }
            }

            if (_isDragging && _dragItem != null)
            {
                if (_dragTarget != null && _dragTarget.Item != _dragItem.Item)
                {
                    ILegendItem potentialParent = _dragTarget.Item.GetValidContainerFor(_dragItem.Item);
                    if (potentialParent != null)
                    {
                        potentialParent.ParentMapFrame().SuspendEvents();

                        // The target must be a group, and the item must be a layer.
                        ILayer lyr = _dragItem.Item as ILayer;
                        if (lyr != null)
                        {
                            IGroup grp = _dragItem.Item.GetParentItem() as IGroup;
                            lyr.LockDispose();
                            //when original location is inside group, remove layer from the group.
                            if (grp != null)
                            {
                                grp.Remove(lyr);
                            }
                            int index = _dragTarget.Item.InsertIndex(_dragItem.Item);
                            if (index == -1)
                            {
                                index = 0;
                            }
                            grp = potentialParent as IGroup;
                            if (grp != null)
                            {
                                grp.Insert(index, lyr);
                                //when the target is a group, assign the parent item.
                                lyr.SetParentItem(grp);
                            }
                            lyr.UnlockDispose();
                        }
                        potentialParent.ParentMapFrame().ResumeEvents();
                        OnOrderChanged();
                        potentialParent.ParentMapFrame().Invalidate();
                    }
                }
                Cursor      = Cursors.Arrow;
                _isDragging = false;
                Invalidate();
            }
            _wasDoubleClick = false;

            base.OnMouseUp(e);
        }
Exemple #45
0
        private void btnRun_Click(object sender, EventArgs e)
        {
            int intDeciPlaces = 5;

            if (cboFldnm1.Text == "" || cboFldnm2.Text == "")
            {
                MessageBox.Show("Please select target field");
                return;
            }

            frmProgress pfrmProgress = new frmProgress();

            pfrmProgress.lblStatus.Text    = "Processing:";
            pfrmProgress.pgbProgress.Style = ProgressBarStyle.Marquee;
            pfrmProgress.Show();

            REngine pEngine = m_pForm.pEngine;
            // Creates the input and output matrices from the shapefile//
            string strLayerName = cboTargetLayer.Text;

            int    intLIndex = m_pSnippet.GetIndexNumberFromLayerName(m_pActiveView, strLayerName);
            ILayer pLayer    = m_pForm.axMapControl1.get_Layer(intLIndex);

            IFeatureLayer pFLayer  = pLayer as IFeatureLayer;
            IFeatureClass pFClass  = pFLayer.FeatureClass;
            int           nFeature = pFClass.FeatureCount(null);

            IFeatureCursor pFCursor = pFLayer.Search(null, true);
            IFeature       pFeature = pFCursor.NextFeature();

            //Get index for independent and dependent variables
            //Get variable index
            string strVarNM1  = (string)cboFldnm1.SelectedItem;
            string strVarNM2  = (string)cboFldnm2.SelectedItem;
            int    intVarIdx1 = pFClass.FindField(strVarNM1);
            int    intVarIdx2 = pFClass.FindField(strVarNM2);

            //Store Variable at Array
            double[] arrVar1 = new double[nFeature];
            double[] arrVar2 = new double[nFeature];

            int i = 0;

            while (pFeature != null)
            {
                arrVar1[i] = Convert.ToDouble(pFeature.get_Value(intVarIdx1));
                arrVar2[i] = Convert.ToDouble(pFeature.get_Value(intVarIdx2));
                i++;
                pFeature = pFCursor.NextFeature();
            }

            //Plot command for R
            StringBuilder plotCommmand = new StringBuilder();

            string strStartPath = m_pForm.strPath;
            string pathr        = strStartPath.Replace(@"\", @"/");

            pEngine.Evaluate("source('" + pathr + "/AllFunctions_LeeL.R')");

            //Get the file path and name to create spatial weight matrix
            string strNameR = m_pSnippet.FilePathinRfromLayer(pFLayer);

            if (strNameR == null)
            {
                return;
            }

            //Create spatial weight matrix in R
            pEngine.Evaluate("library(spdep); library(maptools)");
            pEngine.Evaluate("sample.shp <- readShapePoly('" + strNameR + "')");
            pEngine.Evaluate("sample.nb <- poly2nb(sample.shp)");

            NumericVector vecVar1 = pEngine.CreateNumericVector(arrVar1);

            pEngine.SetSymbol("sample.v1", vecVar1);
            NumericVector vecVar2 = pEngine.CreateNumericVector(arrVar2);

            pEngine.SetSymbol("sample.v2", vecVar2);

            string strNonZeroDiag = null;

            if (chkNonZeroDiag.Checked)
            {
                strNonZeroDiag = "FALSE";
            }
            else
            {
                strNonZeroDiag = "TRUE";
            }

            if (cboSAM.Text == "Lee's L")
            {
                pEngine.Evaluate("sample.g <- L.global.test(sample.v1, sample.v2, sample.nb, style='W', alternative='two.sided', diag.zero=" + strNonZeroDiag + ")");


                //Print Output
                string   strDecimalPlaces = "N" + intDeciPlaces.ToString();
                string[] strResults       = new string[7];
                if (chkNonZeroDiag.Checked)
                {
                    strResults[0] = cboSAM.Text + "* under " + cboAssumption.Text;
                }
                else
                {
                    strResults[0] = cboSAM.Text + "0 under " + cboAssumption.Text;
                }

                strResults[1] = "";
                NumericVector vecResults = pEngine.Evaluate("sample.g$estimate").AsNumeric();
                strResults[2] = "Statistic: " + vecResults[0].ToString(strDecimalPlaces);
                strResults[3] = "Expectation: " + vecResults[1].ToString(strDecimalPlaces);
                strResults[4] = "Variance: " + vecResults[2].ToString(strDecimalPlaces);
                double dblStd  = pEngine.Evaluate("sample.g$statistic").AsNumeric().First();
                double dblPval = pEngine.Evaluate("sample.g$p.value").AsNumeric().First();
                strResults[5] = "Standard deviate: " + dblStd.ToString(strDecimalPlaces);
                strResults[6] = "p-value: " + dblPval.ToString(strDecimalPlaces);

                frmGenResult pfrmResult = new frmGenResult();
                pfrmResult.Text                = "Summary";
                pfrmResult.txtField.Text       = strVarNM1 + " & " + strVarNM2;
                pfrmResult.txtStatistics.Lines = strResults;

                pfrmResult.Show();
            }
            pfrmProgress.Close();
        }
        public void setCurrentValues()
        {
            Globals.Map = ArcMap.Document.FocusMap;

            errorProvider1.Clear();

            Color fc = (Color)ColorTranslator.FromHtml(Globals.getLineFeedbackColorHex());

            linefeedbackColorSwatch.BackColor = fc;

            Color gc = Color.FromArgb(Globals.FlashFeatureColor.Red, Globals.FlashFeatureColor.Green, Globals.FlashFeatureColor.Blue);

            flashColorSwatch.BackColor = gc;

            //CLIDTextBox.Text = Globals.CLID.ToString();
            //APIDTextBox.Text = Globals.APID.ToString();

            flashDelaycomboBox.Text = Globals.FlashFeatureDelay.ToString();

            if (Globals.Workspace != null)
            {
                changeWorkSpace(Globals.Workspace);
            }

            if (Globals.CenterlineLayer != null)
            {
                centerlineLayerComboBox.Text = Globals.CenterlineLayer.Name;
            }
            if (Globals.AddressPointLayer != null)
            {
                addressPointcomboBox.Text = Globals.AddressPointLayer.Name;
            }

            centerlineLayerComboBox.Items.Clear();
            addressPointcomboBox.Items.Clear();

            for (int i = 0; i < ArcMap.Document.FocusMap.LayerCount; i++)
            {
                try
                {
                    ILayer l = ArcMap.Document.FocusMap.get_Layer(i);

                    if (l.SupportedDrawPhases > 5)
                    {
                        IFeatureLayer fl = (IFeatureLayer)l;

                        if (fl.FeatureClass.ShapeType == ESRI.ArcGIS.Geometry.esriGeometryType.esriGeometryLine || fl.FeatureClass.ShapeType == ESRI.ArcGIS.Geometry.esriGeometryType.esriGeometryPolyline)
                        {
                            centerlineLayerComboBox.Items.Add(l.Name);
                        }
                        if (fl.FeatureClass.ShapeType == ESRI.ArcGIS.Geometry.esriGeometryType.esriGeometryPoint)
                        {
                            addressPointcomboBox.Items.Add(l.Name);
                        }
                    }
                }
                catch (Exception ex)
                {
                    log.WriteError(ex, TAG, System.Security.Principal.WindowsIdentity.GetCurrent().Name, null);
                }
            }

            textBox1.Text = Globals.AddressesPerUnit.ToString();
        }
        private static void _add(LayerageCollection layerageCollection, Layerage currentLayerage, Layerage layerage, IEnumerable <Layerage> layerages)
        {
            if (layerage != null)
            {
                if (layerage.Parents != null)
                {
                    //Refactoring
                    ILayer layerageParents = layerage.Parents.Self;
                    layerageParents.IsRefactoringTransformer = true;
                    layerageParents.IsRefactoringRender      = true;
                    layerageParents.IsRefactoringIconRender  = true;
                    layerage.Parents.RefactoringParentsTransformer();
                    layerage.Parents.RefactoringParentsRender();
                    layerage.Parents.RefactoringParentsIconRender();
                }

                IList <Layerage> layerageParentsChildren = layerageCollection.GetParentsChildren(layerage);
                layerageParentsChildren.Remove(layerage);
                currentLayerage.Children.Add(layerage);


                //Refactoring
                ILayer currentLayer = currentLayerage.Self;
                currentLayer.IsRefactoringTransformer = true;
                currentLayer.IsRefactoringRender      = true;
                currentLayer.IsRefactoringIconRender  = true;
                currentLayerage.RefactoringParentsTransformer();
                currentLayerage.RefactoringParentsRender();
                currentLayerage.RefactoringParentsIconRender();
            }
            else if (layerages != null)
            {
                foreach (Layerage child in layerages)
                {
                    if (child.Parents != null)
                    {
                        //Refactoring
                        ILayer childParents = child.Parents.Self;
                        childParents.IsRefactoringTransformer = true;
                        childParents.IsRefactoringRender      = true;
                        childParents.IsRefactoringIconRender  = true;
                        child.Parents.RefactoringParentsTransformer();
                        child.Parents.RefactoringParentsRender();
                        child.Parents.RefactoringParentsIconRender();
                    }


                    IList <Layerage> childParentsChildren = layerageCollection.GetParentsChildren(child);
                    childParentsChildren.Remove(child);
                    currentLayerage.Children.Add(child);


                    //Refactoring
                    ILayer currentLayer = currentLayerage.Self;
                    currentLayer.IsRefactoringTransformer = true;
                    currentLayer.IsRefactoringRender      = true;
                    currentLayer.IsRefactoringIconRender  = true;
                    currentLayerage.RefactoringParentsTransformer();
                    currentLayerage.RefactoringParentsRender();
                    currentLayerage.RefactoringParentsIconRender();
                }
            }
        }
Exemple #48
0
 public Tensor4 CalcDelts(Tensor4 y, ILayer lastLayer)
 {
     this.lastLayer = lastLayer;
     delts          = output - y;
     return(delts);
 }
        /// <summary>
        /// Drag complete.
        /// </summary>
        /// <param name="layerageCollection"> The layerage-collection. </param>
        /// <param name="destination"> The destination layerage. </param>
        /// <param name="source"> The source layerage. </param>
        /// <param name="destinationOverlayMode"> The destination OverlayMode. </param>
        /// <param name="sourceIsSelected"> The source SelectMode. </param>
        public static void DragComplete(LayerageCollection layerageCollection, Layerage destination, Layerage source, OverlayMode destinationOverlayMode, bool sourceIsSelected)
        {
            if (source == null)
            {
                return;
            }
            if (destination == null)
            {
                return;
            }
            ILayer destinationLayer = destination.Self;
            ILayer sourceLayer      = source.Self;

            destinationLayer.Control.OverlayMode = OverlayMode.None;
            if (destinationLayer.IsSelected)
            {
                return;
            }
            if (destinationOverlayMode == OverlayMode.None)
            {
                return;
            }

            if (source == destination)
            {
                return;
            }


            bool isSelected = sourceLayer.IsSelected;

            if (isSelected == false)
            {
                switch (destinationOverlayMode)
                {
                case OverlayMode.Top:
                    LayerageCollection.Insert(layerageCollection, destination, source, isBottomInsert: false);
                    break;

                case OverlayMode.Center:
                    LayerageCollection.Add(layerageCollection, destination, source);
                    break;

                case OverlayMode.Bottom:
                    LayerageCollection.Insert(layerageCollection, destination, source, isBottomInsert: true);
                    break;
                }
            }
            else
            {
                //Layerages
                IEnumerable <Layerage> selectedLayerages = LayerageCollection.GetAllSelected(layerageCollection);

                switch (destinationOverlayMode)
                {
                case OverlayMode.Top:
                    LayerageCollection.InsertRange(layerageCollection, destination, selectedLayerages, isBottomInsert: false);
                    break;

                case OverlayMode.Center:
                    LayerageCollection.AddRange(layerageCollection, destination, selectedLayerages);
                    break;

                case OverlayMode.Bottom:
                    LayerageCollection.InsertRange(layerageCollection, destination, selectedLayerages, isBottomInsert: true);
                    break;
                }
            }
        }
Exemple #50
0
        public InputHandler(ILayer layer)
        {
            Layer = layer;

            SelectedTool = SelectedTool.Silicon;
        }
Exemple #51
0
        public override void Write(byte[] buffer, int offset, int payloadLength, ILayer previousLayer, ILayer nextLayer)
        {
            EthernetType       ethernetType      = EthernetBaseLayer.GetEthernetType(this.EtherType, nextLayer);
            MacAddress         destination       = this.Destination;
            IEthernetNextLayer ethernetNextLayer = nextLayer as IEthernetNextLayer;

            if (destination == MacAddress.Zero && ethernetNextLayer != null && ethernetNextLayer.PreviousLayerDefaultDestination.HasValue)
            {
                destination = ethernetNextLayer.PreviousLayerDefaultDestination.Value;
            }
            EthernetDatagram.WriteHeader(buffer, offset, this.Source, destination, ethernetType);
        }
        private static void _insert(LayerageCollection layerageCollection, Layerage destination, Layerage source, IEnumerable <Layerage> sources, bool isBottomInsert)
        {
            IList <Layerage> parentsChildren = layerageCollection.GetParentsChildren(destination);
            int index = parentsChildren.IndexOf(destination);

            if (isBottomInsert)
            {
                index++;
            }
            if (index < 0)
            {
                index = 0;
            }
            if (index > parentsChildren.Count - 1)
            {
                index = parentsChildren.Count - 1;
            }

            if (source != null)
            {
                if (source.Parents != null)
                {
                    //Refactoring
                    ILayer sourceParents = source.Parents.Self;
                    sourceParents.IsRefactoringTransformer = true;
                    sourceParents.IsRefactoringRender      = true;
                    sourceParents.IsRefactoringIconRender  = true;
                    source.Parents.RefactoringParentsTransformer();
                    source.Parents.RefactoringParentsRender();
                    source.Parents.RefactoringParentsIconRender();
                }


                IList <Layerage> sourceParentsChildren = layerageCollection.GetParentsChildren(source);
                sourceParentsChildren.Remove(source);
                parentsChildren.Insert(index, source);


                if (destination.Parents != null)
                {
                    //Refactoring
                    ILayer destinationParents = destination.Parents.Self;
                    destinationParents.IsRefactoringTransformer = true;
                    destinationParents.IsRefactoringRender      = true;
                    destinationParents.IsRefactoringIconRender  = true;
                    destination.Parents.RefactoringParentsTransformer();
                    destination.Parents.RefactoringParentsRender();
                    destination.Parents.RefactoringParentsIconRender();
                }
            }
            else if (sources != null)
            {
                foreach (Layerage child in sources)
                {
                    if (child.Parents != null)
                    {
                        //Refactoring
                        ILayer childParents = child.Parents.Self;
                        childParents.IsRefactoringTransformer = true;
                        childParents.IsRefactoringRender      = true;
                        childParents.IsRefactoringIconRender  = true;
                        child.Parents.RefactoringParentsTransformer();
                        child.Parents.RefactoringParentsRender();
                        child.Parents.RefactoringParentsIconRender();
                    }

                    IList <Layerage> childParentsChildren = layerageCollection.GetParentsChildren(child);
                    childParentsChildren.Remove(child);
                    parentsChildren.Insert(index, child);
                }
            }


            if (destination.Parents != null)
            {
                //Refactoring
                ILayer destinationParents = destination.Parents.Self;
                destinationParents.IsRefactoringTransformer = true;
                destinationParents.IsRefactoringRender      = true;
                destinationParents.IsRefactoringIconRender  = true;
                destination.Parents.RefactoringParentsTransformer();
                destination.Parents.RefactoringParentsRender();
                destination.Parents.RefactoringParentsIconRender();
            }
        }
        public void Init()
        {
            mainLayer = _renderer.CreateLayer(_width, _height, Layout);
            _renderer.AddLayer(mainLayer);

            TouchManager = new TouchManager(this._game.Client);


            this.NumberCallAreaPosition      = new Point(8, 380);
            this.PreviousCalledBallsPosition = new Point(37, 370);

            this.BingoCardPosition1 = new Point(-9, 20);
            this.BingoCardPosition2 = new Point(151, 20);
            this.BingoCardPosition3 = new Point(-9, 190);
            this.BingoCardPosition4 = new Point(151, 190);

            LeftBoard                        = _renderer.GetImage("leftBoard.leftBoard");
            NumberCallArea                   = _renderer.GetImage("leftBoard.numberCallArea");
            BingoCard                        = _renderer.GetImage("leftBoard.bingoCard");
            PreviousCalledBalls              = _renderer.GetImage("leftBoard.previousCalledBalls");
            ChooseYourCards                  = _renderer.GetImage("leftBoard.chooseYourCards");
            PurchaseBingoCardOutline         = _renderer.GetImage("leftBoard.purchaseBingCardOutline");
            PurchaseBingoCardOutlineSelected = _renderer.GetImage("leftBoard.purchaseBingCardOutlineSelected");

            this.PurchaseBingoCardPosition1 = new Point(4, 5);
            this.PurchaseBingoCardPosition2 = new Point(146, 5);
            this.PurchaseBingoCardPosition3 = new Point(4, 175);
            this.PurchaseBingoCardPosition4 = new Point(146, 175);


            LightBoard        = _renderer.GetImage("leftBoard.lightBoard");
            PurchaseBingoCard = _renderer.GetImage("leftBoard.purchaseBingoCard");

            Icon100  = _renderer.GetImage("icons.100");
            Icon200  = _renderer.GetImage("icons.200");
            Icon300  = _renderer.GetImage("icons.300");
            Icon400  = _renderer.GetImage("icons.400");
            GoldCoin = _renderer.GetImage("icons.goldCoin");



            Purchase1BingoCardPosition = new Point(83, 65);

            Purchase2BingoCardPosition1 = new Point(83 - 4, 65 - 4);
            Purchase2BingoCardPosition2 = new Point(83 + 4, 65 + 4);

            Purchase3BingoCardPosition1 = new Point(83 - 8, 65 - 8);
            Purchase3BingoCardPosition2 = new Point(83 + 0, 65 + 0);
            Purchase3BingoCardPosition3 = new Point(83 + 8, 65 + 8);

            Purchase4BingoCardPosition1 = new Point(83 - 12, 65 - 12);
            Purchase4BingoCardPosition2 = new Point(83 - 4, 65 - 4);
            Purchase4BingoCardPosition3 = new Point(83 + 4, 65 + 4);
            Purchase4BingoCardPosition4 = new Point(83 + 12, 65 + 12);

            PurchaseAmountPosition = new Point(40, 110);
            PurchaseCoinPosition   = new Point(116, 121);


            ChooseYourCardsPosition = new Point(10, 142);
            LightBoardPosition      = new Point(10, 30);
            SetState(BingoLayoutState.PurchaseCards);
            TouchManager.PushClickRect(new TouchRect(0, 0, _width, _height, purchaseCard));
            setupCards();
        }
Exemple #54
0
        /// <summary>
        /// 获取图层感兴趣区的面积
        /// </summary>
        /// <param name="layer"></param>
        /// <returns></returns>
        public static double getLayerAreaEnvelop(ILayer layer)
        {
            IEnvelope pEnvelope = layer.AreaOfInterest;

            return(pEnvelope.Height * pEnvelope.Width);
        }
 /// <summary>
 /// Finalizes the layer data in the buffer.
 /// Used for fields that must be calculated according to the layer's payload (like checksum).
 /// </summary>
 /// <param name="buffer">The buffer to finalize the layer in.</param>
 /// <param name="offset">The offset in the buffer the layer starts.</param>
 /// <param name="payloadLength">The length of the layer's payload (the number of bytes after the layer in the packet).</param>
 /// <param name="nextLayer">The layer that comes after this layer. null if this is the last layer.</param>
 public virtual void Finalize(byte[] buffer, int offset, int payloadLength, ILayer nextLayer)
 {
 }
Exemple #56
0
 public void CalculateParams(ILayer target)
 {
     target.CachedMomentum     = target.LearningRate * target.Momentum;
     target.CachedLearningRate = target.LearningRate * (1 - target.Momentum);
 }
Exemple #57
0
 /// <inheritdoc />
 public virtual bool Contains(ILayer item)
 {
     return(_layers.Contains(item));
 }
Exemple #58
0
        private void btnApply_Click(object sender, EventArgs e)
        {
            try
            {
                Verify();
                string strQuery;
                strQuery = this.txtExpress.Text;
                if (strQuery == "")
                {
                    return;
                }
                ILayer pLayer = null;
                if (layerName != "" || layerName != null)
                {
                    pLayer = ClsSelectQuery.FunFindFeatureLayerByName(layerName, ClsDeclare.g_pMap);
                }
                if (pLayer == null)
                {
                    return;
                }
                IFeatureLayer pFeatLayer;
                pFeatLayer = pLayer as IFeatureLayer;

                if (pFeatLayer.Visible == false)
                {
                }
                //ClsDeclare.g_ErrorHandler.DisplayInformation("请选择可见图层",false,"确定",null);
                IFeatureSelection pFeatureSelection;
                pFeatureSelection = pFeatLayer as IFeatureSelection;

                IQueryFilter pQueryFilter = new QueryFilterClass();
                pQueryFilter.WhereClause = strQuery;

                esriSelectionResultEnum SelType;
                SelType = esriSelectionResultEnum.esriSelectionResultNew;

                //switch (this.cboSelectMethod.Text)
                //{
                //    case "创建一个新的选择结果":
                //        {
                //        if(ClsDeclare.g_pMap.SelectionCount>0)
                //            ClsDeclare.g_pMap.ClearSelection();
                //        SelType = esriSelectionResultEnum.esriSelectionResultNew;

                //        }
                //        break;
                //    case "添加到当前选择集中":
                //        SelType = esriSelectionResultEnum.esriSelectionResultAdd;
                //        break;
                //    case "从当前选择结果中移除":
                //        SelType = esriSelectionResultEnum.esriSelectionResultSubtract;
                //        break;
                //    case "从当前选择结果中选择":
                //        SelType = esriSelectionResultEnum.esriSelectionResultAnd;
                //        break;
                //}
                if (pFeatLayer.Selectable)
                {
                    pFeatureSelection.SelectFeatures(pQueryFilter, SelType, false);
                }

                IActiveView pActiveView;
                pActiveView = ClsDeclare.g_pMap as IActiveView;
                pActiveView.Refresh();

                IFeatureClass       pFeatCls;
                IGeometryCollection pGeometryCol;
                IGeometryBag        pGeometryBag;
                IEnumIDs            pEnumIDs;
                IFeature            pFeature;
                int iOBJID;

                pGeometryCol = new GeometryBagClass();
                pGeometryBag = pGeometryCol as IGeometryBag;
                pFeatCls     = pFeatLayer.FeatureClass;
                pEnumIDs     = pFeatureSelection.SelectionSet.IDs;
                iOBJID       = pEnumIDs.Next();
                object Missing  = Type.Missing;
                object Missing1 = Type.Missing;
                while (iOBJID != -1)
                {
                    pFeature = pFeatCls.GetFeature(iOBJID);
                    pGeometryCol.AddGeometry(pFeature.Shape, ref Missing, ref Missing1);
                    iOBJID = pEnumIDs.Next();
                }

                IHookActions pHookActions;
                IHookHelper  pHookHelper;
                pHookHelper      = new HookHelperClass();
                pHookHelper.Hook = ClsDeclare.g_Sys.MapControl.Object;
                pHookActions     = pHookHelper as IHookActions;
                if (pHookActions.get_ActionSupported(pGeometryBag.Envelope, esriHookActions.esriHookActionsPan))
                {
                    pHookActions.DoAction(pGeometryBag.Envelope, esriHookActions.esriHookActionsPan);
                }
                Application.DoEvents();
            }
            catch (Exception ex)
            {
                MessageBoxEx.Show("错误", ex.StackTrace, MessageBoxButtons.OK, MessageBoxIcon.Error);
                //ClsDeclare.g_ErrorHandler.HandleError(true,null,0,null,ex.StackTrace);
                throw;
            }
        }
Exemple #59
0
 /// <inheritdoc />
 public virtual int IndexOf(ILayer item)
 {
     return(_layers.IndexOf(item));
 }
 /// <summary>
 /// Writes the layer to the buffer.
 /// </summary>
 /// <param name="buffer">The buffer to write the layer to.</param>
 /// <param name="offset">The offset in the buffer to start writing the layer at.</param>
 /// <param name="payloadLength">The length of the layer's payload (the number of bytes after the layer in the packet).</param>
 /// <param name="previousLayer">The layer that comes before this layer. null if this is the first layer.</param>
 /// <param name="nextLayer">The layer that comes after this layer. null if this is the last layer.</param>
 public abstract void Write(byte[] buffer, int offset, int payloadLength, ILayer previousLayer, ILayer nextLayer);