public static ClusteringSpec GetDefaultClusteringSpec(CancellationToken cancellationToken, ReportResults reportResults,
PivotedProperties pivotedProperties)
{
var values = new List <ValueSpec>();
foreach (var seriesGroup in pivotedProperties.SeriesGroups)
{
foreach (var series in seriesGroup.SeriesList)
{
var columnRef = ColumnRef.FromPivotedPropertySeries(series);
if (columnRef == null)
{
continue;
}
if (reportResults.RowCount >= MIN_ROWS_TO_ASSUME_HEADER && EqualValuesInAllRows(cancellationToken, reportResults, series))
{
values.Add(new ValueSpec(columnRef, ClusterRole.COLUMNHEADER));
}
else
{
var transform = ClusterRole.IsNumericType(series.PropertyType)
? ClusterRole.ZSCORE
: ClusterRole.BOOLEAN;
values.Add(new ValueSpec(columnRef, transform));
}
}
}
using (var propertyEnumerator = pivotedProperties.UngroupedProperties.GetEnumerator())
{
while (propertyEnumerator.MoveNext())
{
var columnRef = ColumnRef.FromPropertyDescriptor(propertyEnumerator.Current);
if (columnRef == null)
{
continue;
}
values.Insert(0, new ValueSpec(columnRef, ClusterRole.ROWHEADER));
break;
}
if (values.Count == 1)
{
while (propertyEnumerator.MoveNext())
{
var propertyDescriptor = propertyEnumerator.Current;
if (!ClusterRole.IsNumericType(propertyDescriptor?.PropertyType))
{
continue;
}
var columnRef = ColumnRef.FromPropertyDescriptor(propertyDescriptor);
if (columnRef == null)
{
continue;
}
values.Add(new ValueSpec(columnRef, ClusterRole.RAW));
}
if (values.Count == 1)
{
return(null);
}
}
}
if (values.Count == 0)
{
return(null);
}
return(new ClusteringSpec(values).ChangeDistanceMetric(ClusterMetricType.EUCLIDEAN.Name));
}
public static ReportColorScheme FromClusteredResults(CancellationToken cancellationToken, ClusteredReportResults clusteredReportResults)
{
var discreteColorScheme = new DiscreteColorScheme();
var numericColorScheme = new NumericColorScheme();
var reportResults = clusteredReportResults;
var distinctValues = new HashSet <object>();
var numericValues = new HashSet <double>();
var colorManagers = new Dictionary <string, ColorManager>();
var columnHeaderValues = new Dictionary <string, object>();
var seriesColorManagers = new Dictionary <object, ColorManager>();
foreach (var property in reportResults.ClusteredProperties.RowHeaders)
{
cancellationToken.ThrowIfCancellationRequested();
if (ClusterRole.IsNumericType(property.PropertyType))
{
var colorScheme = new NumericColorScheme();
colorScheme.AddValues(reportResults.RowItems.Select(row => property.GetValue(row)));
colorManagers[property.Name] = new ColorManager(colorScheme, new[] { property }, null);
}
else
{
distinctValues.UnionWith(reportResults.RowItems.Select(property.GetValue).Where(v => null != v));
colorManagers[property.Name] = new ColorManager(discreteColorScheme, new[] { property }, null);
}
}
foreach (var property in reportResults.ClusteredProperties.PivotedProperties.UngroupedProperties)
{
cancellationToken.ThrowIfCancellationRequested();
var transform = reportResults.ClusteredProperties.GetRowTransform(property);
if (transform == null)
{
continue;
}
colorManagers[property.Name] = new ColorManager(numericColorScheme, new[] { property }, transform);
numericValues.UnionWith(reportResults.RowItems
.Select(row => transform.TransformRow(new[] { property.GetValue(row) }).First())
.OfType <double>());
}
foreach (var group in reportResults.PivotedProperties.SeriesGroups)
{
foreach (var series in group.SeriesList)
{
IColorScheme colorScheme = null;
var role = reportResults.ClusteredProperties.GetColumnRole(series);
if (role == ClusterRole.COLUMNHEADER)
{
var values = new HashSet <object>();
foreach (var property in series.PropertyDescriptors)
{
cancellationToken.ThrowIfCancellationRequested();
var columnDistinctValues = reportResults.RowItems.Select(property.GetValue)
.Where(v => null != v).Distinct().ToList();
if (columnDistinctValues.Count == 1)
{
columnHeaderValues[property.Name] = columnDistinctValues[0];
}
values.UnionWith(columnDistinctValues);
}
if (ClusterRole.IsNumericType(series.PropertyType))
{
colorScheme = new NumericColorScheme();
colorScheme.AddValues(values);
}
else
{
distinctValues.UnionWith(values);
colorScheme = discreteColorScheme;
}
}
else if (role is ClusterRole.Transform transform)
{
colorScheme = numericColorScheme;
numericValues.UnionWith(reportResults.RowItems.SelectMany(row =>
{
cancellationToken.ThrowIfCancellationRequested();
return(transform.TransformRow(
series.PropertyDescriptors.Select(pd => pd.GetValue(row))));
}).OfType <double>());
}
if (colorScheme != null)
{
var colorManager = new ColorManager(colorScheme, series.PropertyDescriptors, role as ClusterRole.Transform);
foreach (var pd in series.PropertyDescriptors)
{
colorManagers.Add(pd.Name, colorManager);
}
seriesColorManagers.Add(series.SeriesId, colorManager);
}
}
}
numericColorScheme.AddValues(numericValues);
discreteColorScheme.AddValues(distinctValues);
var columnColors = new Dictionary <string, Color>();
foreach (var entry in columnHeaderValues)
{
if (colorManagers.TryGetValue(entry.Key, out ColorManager manager))
{
var color = manager.ColorScheme.GetColor(entry.Value);
if (color.HasValue)
{
columnColors.Add(entry.Key, color.Value);
}
}
}
return(new ReportColorScheme(reportResults.ClusteredProperties, colorManagers, columnColors, seriesColorManagers));
}
