//
// Create chart
//
private void createChart(RazorChartViewer viewer, int chartIndex)
{
// The value to display on the meter
double value = 66;
// The background and border colors of the meters
int[] bgColor = { 0x88ccff, 0xffdddd };
int[] borderColor = { 0x000077, 0x880000 };
// Create an AngularMeter object of size 300 x 200 pixels with transparent background
AngularMeter m = new AngularMeter(300, 200, Chart.Transparent);
// Center at (150, 150), scale radius = 124 pixels, scale angle -90 to +90 degrees
m.setMeter(150, 150, 124, -90, 90);
// Background gradient color with brighter color at the center
double[] bgGradient = { 0, m.adjustBrightness(bgColor[chartIndex], 3), 0.75, bgColor[
chartIndex] };
// Add a scale background of 148 pixels radius using the background gradient, with a 13 pixel
// thick border
m.addScaleBackground(148, m.relativeRadialGradient(bgGradient), 13, borderColor[chartIndex]);
// Meter scale is 0 - 100, with major tick every 20 units, minor tick every 10 units, and
// micro tick every 5 units
m.setScale(0, 100, 20, 10, 5);
// Set the scale label style to 15pt Arial Italic. Set the major/minor/micro tick lengths to
// 16/16/10 pixels pointing inwards, and their widths to 2/1/1 pixels.
m.setLabelStyle("Arial Italic", 16);
m.setTickLength(-16, -16, -10);
m.setLineWidth(0, 2, 1, 1);
// Demostrate different types of color scales and putting them at different positions
double[] smoothColorScale = { 0, 0x3333ff, 25, 0x0088ff, 50, 0x00ff00, 75, 0xdddd00, 100,
0xff0000 };
if (chartIndex == 0)
{
// Add the smooth color scale at the default position
m.addColorScale(smoothColorScale);
// Add a red (0xff0000) triangular pointer starting from 38% and ending at 60% of scale
// radius, with a width 6 times the default
m.addPointer2(value, 0xff0000, -1, Chart.TriangularPointer2, 0.38, 0.6, 6);
}
else
{
// Add the smooth color scale starting at radius 124 with zero width and ending at radius
// 124 with 16 pixels inner width
m.addColorScale(smoothColorScale, 124, 0, 124, -16);
// Add a red (0xff0000) pointer
m.addPointer2(value, 0xff0000);
}
// Configure a large "pointer cap" to be used as the readout circle at the center. The cap
// radius and border width is set to 33% and 4% of the meter scale radius. The cap color is
// dark blue (0x000044). The border color is light blue (0x66bbff) with a 60% brightness
// gradient effect.
m.setCap2(Chart.Transparent, 0x000044, 0x66bbff, 0.6, 0, 0.33, 0.04);
// Add value label at the center with light blue (0x66ddff) 28pt Arial Italic font
m.addText(150, 150, m.formatValue(value, "{value|0}"), "Arial Italic", 28, 0x66ddff,
Chart.Center).setMargin(0);
// Output the chart
viewer.Image = m.makeWebImage(Chart.PNG);
}
//Main code for creating charts
public void createChart(WPFChartViewer viewer, int chartIndex)
{
// The value to display on the meter
double value = 50;
// The main color of the four meters in this example. The other colors and gradients are
// derived from the main color.
int[] colorList = { 0x007700, 0x770077, 0x0033dd, 0x880000 };
int mainColor = colorList[chartIndex];
//
// In this example, we demonstrate how to parameterized by size, so that the chart size
// can be changed by changing just one variable.
//
int size = 300;
// The radius of the entire meter, which is size / 2, minus 2 pixels for margin
int outerRadius = size / 2 - 2;
// The radius of the meter scale
int scaleRadius = outerRadius * 92 / 100;
// The radius of the inner decorative circle
int innerRadius = scaleRadius * 40 / 100;
// The width of the color scale
int colorScaleWidth = scaleRadius * 10 / 100;
// Major tick length
int tickLength = scaleRadius * 10 / 100;
// Major tick width
int tickWidth = scaleRadius * 1 / 100 + 1;
// Label font size
int fontSize = scaleRadius * 13 / 100;
//
// Create an angular meter based on the above parameters
//
// Create an AngularMeter object of the specified size. In this demo, we use black
// (0x000000) as the background color. You can also use transparent or other colors.
AngularMeter m = new AngularMeter(size, size, 0x000000);
// Set the default text and line colors to white (0xffffff)
m.setColor(Chart.TextColor, 0xffffff);
m.setColor(Chart.LineColor, 0xffffff);
// Set meter center and scale radius, and set the scale angle from -180 to +90 degrees
m.setMeter(size / 2, size / 2, scaleRadius, -180, 90);
// Background gradient with the mainColor at the center and become darker near the
// border
double[] bgGradient = { 0, mainColor, 0.5, m.adjustBrightness(mainColor, 0.75), 1,
m.adjustBrightness(mainColor, 0.15) };
// Fill the meter background with the background gradient
m.addRing(0, outerRadius, m.relativeRadialGradient(bgGradient, outerRadius * 0.66));
// Fill the inner circle with the same background gradient for decoration
m.addRing(0, innerRadius, m.relativeRadialGradient(bgGradient, innerRadius * 0.8));
// Gradient for the neon backlight, with the main color at the scale radius fading to
// transparent
double[] neonGradient = { 0.89, Chart.Transparent, 1, mainColor, 1.07, Chart.Transparent }
;
m.addRing(scaleRadius * 85 / 100, outerRadius, m.relativeRadialGradient(neonGradient));
// The neon ring at the scale radius with width equal to 1/80 of the scale radius,
// creating using a brighter version of the main color
m.addRing(scaleRadius, scaleRadius + scaleRadius / 80, m.adjustBrightness(mainColor, 2))
;
// Meter scale is 0 - 100, with major/minor/micro ticks every 10/5/1 units
m.setScale(0, 100, 10, 5, 1);
// Set the scale label style, tick length and tick width. The minor and micro tick
// lengths are 80% and 60% of the major tick length, and their widths are around half of
// the major tick width.
m.setLabelStyle("Arial Italic", fontSize);
m.setTickLength(-tickLength, -tickLength * 80 / 100, -tickLength * 60 / 100);
m.setLineWidth(0, tickWidth, (tickWidth + 1) / 2, (tickWidth + 1) / 2);
// Demostrate different types of color scales and glare effects and putting them at
// different positions.
double[] smoothColorScale = { 0, 0x0000ff, 25, 0x0088ff, 50, 0x00ff00, 75, 0xdddd00, 100,
0xff0000 };
double[] stepColorScale = { 0, 0x00dd00, 60, 0xddaa00, 80, 0xdd0000, 100 };
double[] highColorScale = { 70, Chart.Transparent, 100, 0xff0000 };
if (chartIndex == 1)
{
// Add the smooth color scale just outside the inner circle
m.addColorScale(smoothColorScale, innerRadius + 1, colorScaleWidth);
// Add glare up to the scale radius, concave and spanning 190 degrees
m.addGlare(scaleRadius, -190);
}
else if (chartIndex == 2)
{
// Add the high color scale at the default position
m.addColorScale(highColorScale);
// Add glare up to the scale radius
m.addGlare(scaleRadius);
}
else
{
// Add the step color scale just outside the inner circle
m.addColorScale(stepColorScale, innerRadius + 1, colorScaleWidth);
// Add glare up to the scale radius, concave and spanning 190 degrees and rotated by
// -45 degrees
m.addGlare(scaleRadius, -190, -45);
}
// Add a red (0xff0000) pointer at the specified value
m.addPointer2(value, 0xff0000);
// Set the cap background to a brighter version of the mainColor, and using black
// (0x000000) for the cap and grey (0x999999) for the cap border
m.setCap2(m.adjustBrightness(mainColor, 1.1), 0x000000, 0x999999);
// Output the chart
viewer.Chart = m;
}
//Main code for creating charts
public void createChart(WinChartViewer viewer, int chartIndex)
{
// The value to display on the meter
double value = 54;
// The main color of the four meters in this example. The other colors and gradients are
// derived from the main color.
int[] colorList = { 0x0033dd, 0xaaaa00 };
int mainColor = colorList[chartIndex];
//
// In this example, we demonstrate how to parameterized by size, so that the chart size
// can be changed by changing just one variable.
//
int size = 300;
// The radius of the entire meter, which is size / 2, minus 2 pixels for margin
int outerRadius = size / 2 - 2;
// The radius of the meter scale
int scaleRadius = outerRadius * 92 / 100;
// The radius of the color scale
int colorScaleRadius = scaleRadius * 43 / 100;
// The width of the color scale
int colorScaleWidth = scaleRadius * 10 / 100;
// Major tick length
int tickLength = scaleRadius * 10 / 100;
// Major tick width
int tickWidth = scaleRadius * 1 / 100 + 1;
// Label font size
int fontSize = scaleRadius * 13 / 100;
// Radius of readout circle as a ratio to the scale radius
double readOutRadiusRatio = 0.333333333333;
// Readout font size
int readOutFontSize = scaleRadius * 24 / 100;
//
// Create an angular meter based on the above parameters
//
// Create an AngularMeter object of the specified size. In this demo, we use black
// (0x000000) as the background color. You can also use transparent or other colors.
AngularMeter m = new AngularMeter(size, size, 0x000000);
// Set the default text and line colors to white (0xffffff)
m.setColor(Chart.TextColor, 0xffffff);
m.setColor(Chart.LineColor, 0xffffff);
// Set meter center and scale radius, and set the scale angle from -180 to +90 degrees
m.setMeter(size / 2, size / 2, scaleRadius, -180, 90);
// Background gradient with the mainColor at the center and become darker near the
// border
double[] bgGradient = { 0, mainColor, 0.5, m.adjustBrightness(mainColor, 0.75), 1,
m.adjustBrightness(mainColor, 0.15) };
// Fill the meter background with the background gradient
m.addRing(0, outerRadius, m.relativeRadialGradient(bgGradient, outerRadius * 0.66));
// Gradient for the neon backlight, with the main color at the scale radius fading to
// transparent
double[] neonGradient = { 0.89, Chart.Transparent, 1, mainColor, 1.07, Chart.Transparent }
;
m.addRing(scaleRadius * 85 / 100, outerRadius, m.relativeRadialGradient(neonGradient));
// The neon ring at the scale radius with width equal to 1/80 of the scale radius,
// creating using a brighter version of the main color
m.addRing(scaleRadius, scaleRadius + scaleRadius / 80, m.adjustBrightness(mainColor, 2))
;
// Meter scale is 0 - 100, with major/minor/micro ticks every 10/5/1 units
m.setScale(0, 100, 10, 5, 1);
// Set the scale label style, tick length and tick width. The minor and micro tick
// lengths are 80% and 60% of the major tick length, and their widths are around half of
// the major tick width.
m.setLabelStyle("Arial Italic", fontSize);
m.setTickLength(-tickLength, -tickLength * 80 / 100, -tickLength * 60 / 100);
m.setLineWidth(0, tickWidth, tickWidth + 1 / 2, tickWidth + 1 / 2);
// Demostrate different types of color scales and putting them at different positions.
double[] smoothColorScale = { 0, 0x0000ff, 25, 0x0088ff, 50, 0x00ff00, 75, 0xdddd00, 100,
0xff0000 };
double[] highColorScale = { 70, Chart.Transparent, 100, 0xff0000 };
if (chartIndex == 0)
{
// Add the smooth color scale
m.addColorScale(smoothColorScale, colorScaleRadius, colorScaleWidth);
// Add a red (0xff0000) pointer
m.addPointer2(value, 0xff0000);
}
else
{
// Add the high color scale at the default position
m.addColorScale(highColorScale);
// Add a red (0xff0000) triangular pointer starting from 40% and ending at 60% of
// scale radius, with a width 6 times the default
m.addPointer2(value, 0xff0000, -1, Chart.TriangularPointer2, 0.4, 0.6, 6);
}
// Configure a large "pointer cap" to be used as the readout circle at the center. The
// cap border width is set to 1.5% of the scale radius. The cap color is darker version
// of the main color. The border color is a brighter version of the main color with 75%
// brightness gradient effect.
m.setCap2(Chart.Transparent, m.adjustBrightness(mainColor, 0.3), m.adjustBrightness(
mainColor, 1.5), 0.75, 0, readOutRadiusRatio, 0.015);
// Add value label at the center using a brighter version of the main color and Arial
// Italic font
m.addText(size / 2, size / 2, m.formatValue(value, "{value|0}"), "Arial Italic",
readOutFontSize, m.adjustBrightness(mainColor, 2.5), Chart.Center).setMargin(0);
// Add glare up to the scale radius
m.addGlare(scaleRadius);
// Output the chart
viewer.Chart = m;
}