コード例 #1
0
        private void Draw()
        {
            byte[][] defaultColourScheme;
            int      nClassesValue = 3;
            string   colourSchemeComboBoxSelection = colourSchemeComboBox.SelectedValue.ToString();

            if (!_datasetModel.IsColourQualitative)
            {
                ComboBoxItem nClassesComboBoxSelection = (ComboBoxItem)numDataClassesComboBox.SelectedValue;
                nClassesValue       = int.Parse(nClassesComboBoxSelection.Content.ToString());
                defaultColourScheme = _colourScheme.GetRGBColours(colourSchemeComboBoxSelection, nClassesValue);
            }
            else
            {
                nClassesValue       = _distinctCategories.Count();
                defaultColourScheme = _colourScheme.GetRGBColours(colourSchemeComboBoxSelection, nClassesValue);
            }

            foreach (TreemapRow row in _rows)
            {
                foreach (TreemapNode node in row.Nodes)
                {
                    Canvas.SetLeft(node, node.XPos);
                    Canvas.SetTop(node, node.YPos);
                    canvas.Children.Add(node);

                    if (_datasetModel.IsColourQualitative)
                    {
                        int index = _distinctCategories.IndexOf(node.ColourValue);
                        node.Colour = defaultColourScheme[index];
                    }
                    else
                    {
                        double colourValue     = double.Parse(node.ColourValue);
                        double linearTransform = (colourValue - _datasetModel.ColourMinMax[0]) /
                                                 (_datasetModel.ColourMinMax[1] - _datasetModel.ColourMinMax[0]) * (nClassesValue - 1);
                        int colourIndex = (int)Math.Truncate(linearTransform);
                        node.Colour = defaultColourScheme[colourIndex];
                    }
                }
            }

            // Assign event handlers at the end so events are not fired during initialisation
            numDataClassesComboBox.SelectionChanged   += numDataClassesComboBox_SelectionChanged;
            colourSchemeTypeComboBox.SelectionChanged += colourSchemeTypeComboBox_SelectionChanged;
            colourSchemeComboBox.SelectionChanged     += colourSchemeComboBox_SelectionChanged;
        }
コード例 #2
0
        private void Draw()
        {
            _dataGrid.CollectionChanged -= dataGrid_CollectionChanged;
            _dataGrid.Clear();

            // get colour scheme values from combobox selections
            ComboBoxItem nDataClassesSelection = numDataClassesComboBox.SelectedItem as ComboBoxItem;
            int          nDataClasses          = int.Parse(nDataClassesSelection.Content.ToString());

            byte[][] defaultColourScheme = _colourScheme.GetRGBColours(colourSchemeComboBox.SelectedItem.ToString(), nDataClasses);

            for (int i = 0; i < _datasetModel.Dataset.Count; i++)
            {
                string[]     row     = _datasetModel.Dataset[i];
                ListViewItem item    = BuildRowStructure(_cellWidth, row[_idIndex]);
                Grid         rowGrid = item.Content as Grid;

                for (int j = 0; j < this.Columns.Length; j++)
                {
                    int    currentColumn = _columnIndexes[j];
                    string columnTitle   = _datasetModel.ColumnHeadings[currentColumn];

                    // get max and min for the column
                    double[] minMax = _datasetModel.GetAxisMinMaxValues(columnTitle);
                    double   min    = minMax[0];
                    double   max    = minMax[1];

                    double cellValue       = double.Parse(row[currentColumn]);
                    double linearTransform = (cellValue - min) / (max - min) * (nDataClasses - 1);
                    int    colourIndex     = (int)Math.Truncate(linearTransform);
                    byte[] colourRGB       = defaultColourScheme[colourIndex];

                    Rectangle cell = new Rectangle();
                    cell.Stroke          = new SolidColorBrush(Colors.LightGray);
                    cell.StrokeThickness = 1;
                    cell.Fill            = new SolidColorBrush(Color.FromArgb(255, colourRGB[0], colourRGB[1], colourRGB[2]));

                    ToolTip tt = new ToolTip();
                    tt.Content   = row[currentColumn];
                    tt.Placement = Windows.UI.Xaml.Controls.Primitives.PlacementMode.Mouse;
                    ToolTipService.SetToolTip(cell, tt);

                    rowGrid.Children.Add(cell);
                    // add to column + 1 to account for the row title
                    Grid.SetColumn(cell, j + 1);
                }
                _dataGrid.Add(item);
            }

            _dataGrid.CollectionChanged += dataGrid_CollectionChanged;
            dataListView.ItemsSource     = _dataGrid;

            // check for filtered items
            if (_filteredItems.Count > 0)
            {
                Filter();
            }
        }
コード例 #3
0
        private async void CreateBubbles()
        {
            StringBuilder sb = new StringBuilder();

            byte[][] colourSchemeArray;
            int      nClassesValue = 3;
            string   colourSchemeComboBoxSelection = colourSchemeComboBox.SelectedValue.ToString();

            if (!_datasetModel.IsColourQualitative)
            {
                ComboBoxItem nClassesComboBoxSelection = (ComboBoxItem)numDataClassesComboBox.SelectedValue;
                nClassesValue     = int.Parse(nClassesComboBoxSelection.Content.ToString());
                colourSchemeArray = _colourScheme.GetRGBColours(colourSchemeComboBoxSelection, nClassesValue);
            }
            else
            {
                nClassesValue     = _distinctCategories.Count();
                colourSchemeArray = _colourScheme.GetRGBColours(colourSchemeComboBoxSelection, nClassesValue);
            }

            for (int i = 0; i < _datasetModel.Dataset.Count; i++)
            {
                string[] row = _datasetModel.Dataset[i];

                BubblePushpin bubble = new BubblePushpin();
                bubble.OriginalBubbleSize = double.Parse(row[_symbolSizeIndex]);
                bubble.BubbleSize         = bubble.OriginalBubbleSize;
                bubble.ColourValue        = row[_symbolColourIndex];

                // use StringBuilder to create the tooltip details
                sb.AppendLine(row[_placeNameIndex]);
                sb.Append(_datasetModel.ColumnHeadings[_symbolSizeIndex]);
                sb.Append(": ");
                sb.AppendLine(row[_symbolSizeIndex]);
                sb.Append(_datasetModel.ColumnHeadings[_symbolColourIndex]);
                sb.Append(": ");
                sb.Append(row[_symbolColourIndex]);
                if (!String.IsNullOrEmpty(this.Description))
                {
                    sb.Append(": ");
                    sb.Append(row[_descriptionIndex]);
                }
                bubble.Details = sb.ToString();

                // plot symbols on map - if lat/lon not set then geocode the place name
                if (String.IsNullOrEmpty(this.Latitude) || String.IsNullOrEmpty(this.Longitude) ||
                    String.IsNullOrEmpty(row[_latitideIndex]) || String.IsNullOrEmpty(row[_longitudeIndex]))
                {
                    Bing.Maps.Location geocodedLocation = await GeocodePlaceName(row[_placeNameIndex]);

                    bubble.LatLon = geocodedLocation;
                }
                else
                {
                    double latitude  = 0.0;
                    double longitude = 0.0;

                    if (!double.TryParse(row[_latitideIndex], out latitude) ||
                        !double.TryParse(row[_longitudeIndex], out longitude))
                    {
                        await new MessageDialog("Cannot parse latitude/longitude for " + row[_placeNameIndex],
                                                "Error parsing dataset").ShowAsync();
                    }

                    bubble.LatLon = new Bing.Maps.Location(latitude, longitude);
                }

                // Apply colour
                if (_datasetModel.IsColourQualitative)
                {
                    int index = _distinctCategories.IndexOf(row[_symbolColourIndex]);
                    bubble.Colour = colourSchemeArray[index];
                }
                else
                {
                    double colourValue     = double.Parse(row[_symbolColourIndex]);
                    double linearTransform = (colourValue - _datasetModel.ColourMinMax[0]) /
                                             (_datasetModel.ColourMinMax[1] - _datasetModel.ColourMinMax[0]) * (nClassesValue - 1);
                    int colourIndex = (int)Math.Truncate(linearTransform);
                    bubble.Colour = colourSchemeArray[colourIndex];
                }

                _bubblePushpins.Add(bubble);
                sb.Clear();
            }

            Draw();
        }
コード例 #4
0
        private void Draw()
        {
            StringBuilder sb = new StringBuilder();

            byte[][] defaultColourScheme;
            int      nClassesValue = 3;
            string   colourSchemeComboBoxSelection = colourSchemeComboBox.SelectedValue.ToString();

            if (!_datasetModel.IsColourQualitative)
            {
                ComboBoxItem nClassesComboBoxSelection = (ComboBoxItem)numDataClassesComboBox.SelectedValue;
                nClassesValue       = int.Parse(nClassesComboBoxSelection.Content.ToString());
                defaultColourScheme = _colourScheme.GetRGBColours(colourSchemeComboBoxSelection, nClassesValue);
            }
            else
            {
                _distinctCategories = _datasetModel.Dataset.Select(o => o[_colourValueIndex]).Distinct().ToList();
                nClassesValue       = _distinctCategories.Count();
                defaultColourScheme = _colourScheme.GetRGBColours(colourSchemeComboBoxSelection, nClassesValue);
            }

            foreach (string[] row in _datasetModel.Dataset)
            {
                ParallelCoordsPolyline line = new ParallelCoordsPolyline();
                line.ColourValue = row[_colourValueIndex];
                sb.AppendLine(row[_idIndex]);

                // Apply line colour
                if (_datasetModel.IsColourQualitative)
                {
                    int index = _distinctCategories.IndexOf(row[_colourValueIndex]);
                    line.LineColour = defaultColourScheme[index];
                }
                else
                {
                    double colourValue     = double.Parse(row[_colourValueIndex]);
                    double linearTransform = (colourValue - _datasetModel.ColourMinMax[0]) /
                                             (_datasetModel.ColourMinMax[1] - _datasetModel.ColourMinMax[0]) * (nClassesValue - 1);
                    int colourIndex = (int)Math.Truncate(linearTransform);
                    line.LineColour = defaultColourScheme[colourIndex];
                }

                PointCollection points     = new PointCollection();
                double[]        dataValues = new double[_axesIndexes.Length];

                for (int i = 0; i < _axesIndexes.Length; i++)
                {
                    // get value for the axis
                    double val = double.Parse(row[_axesIndexes[i]]);
                    dataValues[i] = val;

                    // get max/min values for the axis
                    string   axisTitle = _datasetModel.ColumnHeadings[_axesIndexes[i]];
                    double[] minMax    = _datasetModel.GetAxisMinMaxValues(axisTitle);

                    // get normalised value (between 0 and 1) and multiply
                    // by screen height to convert it into a screen coordinate
                    double yCoord = NormaliseValue(val, minMax[1], minMax[0]) * _canvasHeight;
                    double xCoord = _xSeparation * i;

                    points.Add(new Point(xCoord, yCoord));

                    sb.Append(_datasetModel.ColumnHeadings[_axesIndexes[i]]);
                    sb.Append(": ");
                    sb.AppendLine(val.ToString());
                }

                // colour value tooltip text
                // check to see if the colour value is already an axis
                if (Array.IndexOf(this.Axes, this.ColourValue) < 0)
                {
                    // colour value is not an axis, add to the tooltip text
                    sb.Append(_datasetModel.ColumnHeadings[_colourValueIndex]);
                    sb.Append(": ");
                    sb.Append(row[_colourValueIndex]);
                }

                line.Details = sb.ToString();
                sb.Clear();

                line.PolylinePoints = points;
                line.DataValues     = dataValues;
                _polylines.Add(line);
                canvas.Children.Add(line);
            }

            // Assign event handlers at the end so events are not fired during initialisation
            numDataClassesComboBox.SelectionChanged   += numDataClassesComboBox_SelectionChanged;
            colourSchemeTypeComboBox.SelectionChanged += colourSchemeTypeComboBox_SelectionChanged;
            colourSchemeComboBox.SelectionChanged     += colourSchemeComboBox_SelectionChanged;
        }