Exemple #1
0
        private void btnDelete_Click(object sender, EventArgs e)
        {
            if (dgvCategories.SelectedRows.Count == 0)
            {
                return;
            }
            List <IColorCategory>   deleteList = new List <IColorCategory>();
            ColorCategoryCollection categories = _newScheme.Categories;
            int count = 0;

            foreach (DataGridViewRow row in dgvCategories.SelectedRows)
            {
                int index = dgvCategories.Rows.IndexOf(row);
                deleteList.Add(categories[index]);
                count++;
            }
            foreach (IColorCategory category in deleteList)
            {
                int index = categories.IndexOf(category);
                if (index > 0 && index < categories.Count - 1)
                {
                    categories[index - 1].Maximum = categories[index + 1].Minimum;
                    categories[index - 1].ApplyMinMax(_newScheme.EditorSettings);
                }
                _newScheme.RemoveCategory(category);
                breakSliderGraph1.UpdateBreaks();
            }
            UpdateTable();
            _newScheme.EditorSettings.IntervalMethod = IntervalMethod.Manual;
            _newScheme.EditorSettings.NumBreaks     -= count;
            UpdateStatistics(false);
        }
Exemple #2
0
        /// <summary>
        /// Updates the Table using the unique values.
        /// </summary>
        private void UpdateTable()
        {
            dgvCategories.SuspendLayout();
            dgvCategories.Rows.Clear();

            ColorCategoryCollection breaks = _newScheme.Categories;
            int i = 0;

            if (breaks.Count > 0)
            {
                dgvCategories.Rows.Add(breaks.Count);
                foreach (IColorCategory brk in breaks)
                {
                    dgvCategories[1, i].Value = brk.Range.ToString(_symbolizer.EditorSettings.IntervalSnapMethod, _symbolizer.EditorSettings.IntervalRoundingDigits);
                    dgvCategories[2, i].Value = brk.LegendText;
                    i++;
                }
            }

            dgvCategories.ResumeLayout();
            dgvCategories.Invalidate();
        }
Exemple #3
0
        private void DgvCategoriesCellValidated(object sender, DataGridViewCellEventArgs e)
        {
            if (_ignoreValidation)
            {
                return;
            }
            if (_newScheme.Categories.Count <= e.RowIndex)
            {
                return;
            }

            if (e.ColumnIndex == 2)
            {
                IColorCategory fctxt = _newScheme.Categories[e.RowIndex];
                fctxt.LegendText = (string)dgvCategories[e.ColumnIndex, e.RowIndex].Value;
                return;
            }

            if (e.ColumnIndex != 1)
            {
                return;
            }

            IColorCategory cb = _newScheme.Categories[e.RowIndex];

            if ((string)dgvCategories[e.ColumnIndex, e.RowIndex].Value == cb.LegendText)
            {
                return;
            }
            _ignoreEnter = true;
            string exp = (string)dgvCategories[e.ColumnIndex, e.RowIndex].Value;

            cb.LegendText = exp;

            cb.Range = new Range(exp);
            if (cb.Range.Maximum != null && cb.Range.Maximum > _raster.Maximum)
            {
                cb.Range.Maximum = _raster.Maximum;
            }

            if (cb.Range.Minimum != null && cb.Range.Minimum > _raster.Maximum)
            {
                cb.Range.Minimum = _raster.Maximum;
            }

            if (cb.Range.Maximum != null && cb.Range.Minimum < _raster.Minimum)
            {
                cb.Range.Minimum = _raster.Minimum;
            }

            if (cb.Range.Minimum != null && cb.Range.Minimum < _raster.Minimum)
            {
                cb.Range.Minimum = _raster.Minimum;
            }

            cb.ApplyMinMax(_newScheme.EditorSettings);
            ColorCategoryCollection breaks = _newScheme.Categories;

            breaks.SuspendEvents();
            if (cb.Range.Minimum == null && cb.Range.Maximum == null)
            {
                breaks.Clear();
                breaks.Add(cb);
            }
            else if (cb.Range.Maximum == null)
            {
                List <IColorCategory> removeList = new();

                int iPrev = e.RowIndex - 1;
                for (int i = 0; i < e.RowIndex; i++)
                {
                    // If the specified max is below the minima of a lower range, remove the lower range.
                    if (breaks[i].Minimum > cb.Minimum)
                    {
                        removeList.Add(breaks[i]);
                        iPrev--;
                    }
                    else if (breaks[i].Maximum > cb.Minimum || i == iPrev)
                    {
                        // otherwise, if the maximum of a lower range is higher than the value, adjust it.
                        breaks[i].Maximum = cb.Minimum;
                        breaks[i].ApplyMinMax(_symbolizer.EditorSettings);
                    }
                }

                for (int i = e.RowIndex + 1; i < breaks.Count; i++)
                {
                    // Since we have just assigned an absolute maximum, any previous categories
                    // that fell above the edited category should be removed.
                    removeList.Add(breaks[i]);
                }

                foreach (IColorCategory brk in removeList)
                {
                    // Do the actual removal.
                    breaks.Remove(brk);
                }
            }
            else if (cb.Range.Minimum == null)
            {
                List <IColorCategory> removeList = new();

                int iNext = e.RowIndex + 1;
                for (int i = e.RowIndex + 1; i < breaks.Count; i++)
                {
                    // If the specified max is below the minima of a lower range, remove the lower range.
                    if (breaks[i].Maximum < cb.Maximum)
                    {
                        removeList.Add(breaks[i]);
                        iNext++;
                    }
                    else if (breaks[i].Minimum < cb.Maximum || i == iNext)
                    {
                        // otherwise, if the maximum of a lower range is higher than the value, adjust it.
                        breaks[i].Minimum = cb.Maximum;
                        breaks[i].ApplyMinMax(_symbolizer.EditorSettings);
                    }
                }

                for (int i = 0; i < e.RowIndex; i++)
                {
                    // Since we have just assigned an absolute minimum, any previous categories
                    // that fell above the edited category should be removed.
                    removeList.Add(breaks[i]);
                }

                foreach (IColorCategory brk in removeList)
                {
                    // Do the actual removal.
                    breaks.Remove(brk);
                }
            }
            else
            {
                // We have two values. Adjust any above or below that conflict.
                List <IColorCategory> removeList = new();
                int iPrev = e.RowIndex - 1;
                for (int i = 0; i < e.RowIndex; i++)
                {
                    // If the specified max is below the minima of a lower range, remove the lower range.
                    if (breaks[i].Minimum > cb.Minimum)
                    {
                        removeList.Add(breaks[i]);
                        iPrev--;
                    }
                    else if (breaks[i].Maximum > cb.Minimum || i == iPrev)
                    {
                        // otherwise, if the maximum of a lower range is higher than the value, adjust it.
                        breaks[i].Maximum = cb.Minimum;
                        breaks[i].ApplyMinMax(_symbolizer.EditorSettings);
                    }
                }

                int iNext = e.RowIndex + 1;
                for (int i = e.RowIndex + 1; i < breaks.Count; i++)
                {
                    // If the specified max is below the minima of a lower range, remove the lower range.
                    if (breaks[i].Maximum < cb.Maximum)
                    {
                        removeList.Add(breaks[i]);
                        iNext++;
                    }
                    else if (breaks[i].Minimum < cb.Maximum || i == iNext)
                    {
                        // otherwise, if the maximum of a lower range is higher than the value, adjust it.
                        breaks[i].Minimum = cb.Maximum;
                        breaks[i].ApplyMinMax(_symbolizer.EditorSettings);
                    }
                }

                foreach (IColorCategory brk in removeList)
                {
                    // Do the actual removal.
                    breaks.Remove(brk);
                }
            }

            breaks.ResumeEvents();
            _ignoreRefresh           = true;
            cmbInterval.SelectedItem = IntervalMethod.Manual;
            _symbolizer.EditorSettings.IntervalMethod = IntervalMethod.Manual;
            _ignoreRefresh = false;
            UpdateStatistics(false);
            _cleanupTimer.Start();
        }
        public void ApplyScheme(ColorSchemes scheme, IRaster raster)
        {
            GetValues(raster);
            double min = Statistics.Minimum;
            double max = Statistics.Maximum;
            
            if (Categories == null)
            {
                Categories = new ColorCategoryCollection(this);
            }
            int alpha = ByteRange(Convert.ToInt32(_opacity * 255F));
            // this part should be overridden in the type specific version
           
            Categories.Clear();
            IColorCategory low = new ColorCategory(min, (min + max)/2);
            low.Range.MaxIsInclusive = true;
            IColorCategory high = new ColorCategory((min + max)/2, max);
            high.Range.MaxIsInclusive = true;
            low.ApplyMinMax(EditorSettings);
            high.ApplyMinMax(EditorSettings);
            Categories.Add(low);
            Categories.Add(high);
            switch (scheme)
            {
                case ColorSchemes.Summer_Mountains:
                    low.LowColor = Color.FromArgb(alpha, 10, 100, 10);
                    low.HighColor = Color.FromArgb(alpha, 153, 125, 25);
                    high.LowColor = Color.FromArgb(alpha, 153, 125, 25);
                    high.HighColor = Color.FromArgb(alpha, 255, 255, 255);
                    break;
                case ColorSchemes.FallLeaves:
                    low.LowColor = Color.FromArgb(alpha, 10, 100, 10);
                    low.HighColor = Color.FromArgb(alpha, 199, 130, 61);
                    high.LowColor = Color.FromArgb(alpha, 199, 130, 61);
                    high.HighColor = Color.FromArgb(alpha, 241, 220, 133);
                    break;
                case ColorSchemes.Desert:
                    low.LowColor = Color.FromArgb(alpha, 211, 206, 97);
                    low.HighColor = Color.FromArgb(alpha, 139, 120, 112);
                    high.LowColor = Color.FromArgb(alpha, 139, 120, 112);
                    high.HighColor = Color.FromArgb(alpha, 255, 255, 255);
                    break;
                case ColorSchemes.Glaciers:
                    low.LowColor = Color.FromArgb(alpha, 105, 171, 224);
                    low.HighColor = Color.FromArgb(alpha, 162, 234, 240);
                    high.LowColor = Color.FromArgb(alpha, 162, 234, 240);
                    high.HighColor = Color.FromArgb(alpha, 255, 255, 255);
                    break;
                case ColorSchemes.Meadow:
                    low.LowColor = Color.FromArgb(alpha, 68, 128, 71);
                    low.HighColor = Color.FromArgb(alpha, 43, 91, 30);
                    high.LowColor = Color.FromArgb(alpha, 43, 91, 30);
                    high.HighColor = Color.FromArgb(alpha, 167, 220, 168);
                    break;
                case ColorSchemes.Valley_Fires:
                    low.LowColor = Color.FromArgb(alpha, 164, 0, 0);
                    low.HighColor = Color.FromArgb(alpha, 255, 128, 64);
                    high.LowColor = Color.FromArgb(alpha, 255, 128, 64);
                    high.HighColor = Color.FromArgb(alpha, 255, 255, 191);
                    break;
                case ColorSchemes.DeadSea:
                    low.LowColor = Color.FromArgb(alpha, 51, 137, 208);
                    low.HighColor = Color.FromArgb(alpha, 226, 227, 166);
                    high.LowColor = Color.FromArgb(alpha, 226, 227, 166);
                    high.HighColor = Color.FromArgb(alpha, 151, 146, 117);
                    break;
                case ColorSchemes.Highway:
                    low.LowColor = Color.FromArgb(alpha, 51, 137, 208);
                    low.HighColor = Color.FromArgb(alpha, 214, 207, 124);
                    high.LowColor = Color.FromArgb(alpha, 214, 207, 124);
                    high.HighColor = Color.FromArgb(alpha, 54, 152, 69);
                    break;
                default:
                    break;

            }
           
            OnItemChanged(this);
        }
 /// <summary>
 /// Creates a new instance of ColorScheme
 /// </summary>
 public ColorScheme()
 {
     _categories = new ColorCategoryCollection(this);
     _opacity = 1;
     EditorSettings = new RasterEditorSettings();
 }
 private void Configure()
 {
     _categories = new ColorCategoryCollection(this);
     _opacity = 1;
     EditorSettings = new RasterEditorSettings();
 }
Exemple #7
0
        /// <summary>
        /// Applies the specified color scheme and uses the specified raster to define the
        /// minimum and maximum to use for the scheme.
        /// </summary>
        /// <param name="schemeType">ColorSchemeType</param>
        /// <param name="min">THe minimum value to use for the scheme</param>
        /// <param name="max">THe maximum value to use for the scheme</param>
        public void ApplyScheme(ColorSchemeType schemeType, double min, double max)
        {
            if (Categories == null)
            {
                Categories = new ColorCategoryCollection(this);
            }
            else
            {
                Categories.Clear();    
            }

            IColorCategory eqCat = null, low = null, high = null;
            if (min == max)
            {
                // Create one category
                eqCat = new ColorCategory(min, max) {Range = {MaxIsInclusive = true, MinIsInclusive = true}};
                eqCat.ApplyMinMax(EditorSettings);
                Categories.Add(eqCat);
            }
            else
            {
                // Create two categories
                low = new ColorCategory(min, (min + max) / 2) {Range = {MaxIsInclusive = true}};
                high = new ColorCategory((min + max) / 2, max) {Range = {MaxIsInclusive = true}};
                low.ApplyMinMax(EditorSettings);
                high.ApplyMinMax(EditorSettings);
                Categories.Add(low);
                Categories.Add(high);    
            }

            Color lowColor, midColor, highColor;
            int alpha = ByteRange(Convert.ToInt32(_opacity * 255F));
            switch (schemeType)
            {
                case ColorSchemeType.Summer_Mountains:
                    lowColor = Color.FromArgb(alpha, 10, 100, 10);
                    midColor = Color.FromArgb(alpha, 153, 125, 25);
                    highColor = Color.FromArgb(alpha, 255, 255, 255);
                    break;
                case ColorSchemeType.FallLeaves:
                    lowColor = Color.FromArgb(alpha, 10, 100, 10);
                    midColor = Color.FromArgb(alpha, 199, 130, 61);
                    highColor = Color.FromArgb(alpha, 241, 220, 133);
                    break;
                case ColorSchemeType.Desert:
                    lowColor = Color.FromArgb(alpha, 211, 206, 97);
                    midColor = Color.FromArgb(alpha, 139, 120, 112);
                    highColor = Color.FromArgb(alpha, 255, 255, 255);
                    break;
                case ColorSchemeType.Glaciers:
                    lowColor = Color.FromArgb(alpha, 105, 171, 224);
                    midColor = Color.FromArgb(alpha, 162, 234, 240);
                    highColor = Color.FromArgb(alpha, 255, 255, 255);
                    break;
                case ColorSchemeType.Meadow:
                    lowColor = Color.FromArgb(alpha, 68, 128, 71);
                    midColor = Color.FromArgb(alpha, 43, 91, 30);
                    highColor = Color.FromArgb(alpha, 167, 220, 168);
                    break;
                case ColorSchemeType.Valley_Fires:
                    lowColor = Color.FromArgb(alpha, 164, 0, 0);
                    midColor = Color.FromArgb(alpha, 255, 128, 64);
                    highColor = Color.FromArgb(alpha, 255, 255, 191);
                    break;
                case ColorSchemeType.DeadSea:
                    lowColor = Color.FromArgb(alpha, 51, 137, 208);
                    midColor = Color.FromArgb(alpha, 226, 227, 166);
                    highColor = Color.FromArgb(alpha, 151, 146, 117);
                    break;
                case ColorSchemeType.Highway:
                    lowColor = Color.FromArgb(alpha, 51, 137, 208);
                    midColor = Color.FromArgb(alpha, 214, 207, 124);
                    highColor = Color.FromArgb(alpha, 54, 152, 69);
                    break;
                default:
                    lowColor = midColor = highColor = Color.Transparent;
                    break;
            }

            if (eqCat != null)
            {
                eqCat.LowColor = eqCat.HighColor = lowColor;
            }
            else
            {
                Debug.Assert(low != null);
                Debug.Assert(high != null);

                low.LowColor = lowColor;
                low.HighColor = midColor;
                high.LowColor = midColor;
                high.HighColor = highColor;
            }

            OnItemChanged(this);
        }