Circular Gauge Custom Control for Silverlight 3 and WPF

 //Drawing the scale with the Scale Radius
        private void DrawScale()
        {
            //Calculate one major tick angle 
            Double majorTickUnitAngle = ScaleSweepAngle / MajorDivisionsCount;

            //Obtaining One minor tick angle 
            Double minorTickUnitAngle = ScaleSweepAngle / MinorDivisionsCount;

            //Obtaining One major ticks value
            Double majorTicksUnitValue = (MaxValue - MinValue) / MajorDivisionsCount;
            majorTicksUnitValue = Math.Round(majorTicksUnitValue, ScaleValuePrecision);

            Double minvalue = MinValue; ;

            // Drawing Major scale ticks
            for (Double i = ScaleStartAngle; i <= (ScaleStartAngle + ScaleSweepAngle); i = i + majorTickUnitAngle)
            {

                //Majortick is drawn as a rectangle 
                Rectangle majortickrect = new Rectangle();
                majortickrect.Height = MajorTickSize.Height;
                majortickrect.Width = MajorTickSize.Width;
                majortickrect.Fill = new SolidColorBrush(MajorTickColor);
                Point p = new Point(0.5, 0.5);
                majortickrect.RenderTransformOrigin = p;
                majortickrect.HorizontalAlignment = HorizontalAlignment.Center;
                majortickrect.VerticalAlignment = VerticalAlignment.Center;

                TransformGroup majortickgp = new TransformGroup();
                RotateTransform majortickrt = new RotateTransform();

                //Obtaining the angle in radians for calulating the points
                Double i_radian = (i * Math.PI) / 180;
                majortickrt.Angle = i;
                majortickgp.Children.Add(majortickrt);
                TranslateTransform majorticktt = new TranslateTransform();

                //Finding the point on the Scale where the major ticks are drawn
                //here drawing the points with center as (0,0)
                majorticktt.X = (int)((ScaleRadius) * Math.Cos(i_radian));
                majorticktt.Y = (int)((ScaleRadius) * Math.Sin(i_radian));

                //Points for the textblock which hold the scale value
                TranslateTransform majorscalevaluett = new TranslateTransform();
                //here drawing the points with center as (0,0)
                majorscalevaluett.X = (int)((ScaleLabelRadius) * Math.Cos(i_radian));
                majorscalevaluett.Y = (int)((ScaleLabelRadius) * Math.Sin(i_radian));

                //Defining the properties of the scale value textbox
                TextBlock tb = new TextBlock();

                tb.Height = ScaleLabelSize.Height;
                tb.Width = ScaleLabelSize.Width;

//**************************************************************************** BEGIN CHANGE HERE

                if (ScaleLabelFontSize < 1)
                {
                    tb.FontSize = 10;
                }
                else
                {
                    tb.FontSize = ScaleLabelFontSize;
                }

//********************************************************************************** END CHANGE HERE
                tb.Foreground = new SolidColorBrush(ScaleLabelForeground);
                tb.TextAlignment = TextAlignment.Center;
                tb.VerticalAlignment = VerticalAlignment.Center;
                tb.HorizontalAlignment = HorizontalAlignment.Center;

                //Writing and appending the scale value

                //checking minvalue < maxvalue w.r.t scale precion value
                if (Math.Round(minvalue, ScaleValuePrecision) <= Math.Round(MaxValue, ScaleValuePrecision))
                {
                    minvalue = Math.Round(minvalue, ScaleValuePrecision);
                    tb.Text = minvalue.ToString();
                    minvalue = minvalue + majorTicksUnitValue;

                }
                else
                {
                    break;
                }
                majortickgp.Children.Add(majorticktt);
                majortickrect.RenderTransform = majortickgp;
                tb.RenderTransform = majorscalevaluett;
                rootGrid.Children.Add(majortickrect);
                rootGrid.Children.Add(tb);


                //Drawing the minor axis ticks
                Double onedegree = ((i + majorTickUnitAngle) - i) / (MinorDivisionsCount);

                if ((i < (ScaleStartAngle + ScaleSweepAngle)) && (Math.Round(minvalue, ScaleValuePrecision) <= Math.Round(MaxValue, ScaleValuePrecision)))
                {
                    //Drawing the minor scale
                    for (Double mi = i + onedegree; mi < (i + majorTickUnitAngle); mi = mi + onedegree)
                    {
                        //here the minortick is drawn as a rectangle 
                        Rectangle mr = new Rectangle();
                        mr.Height = MinorTickSize.Height;
                        mr.Width = MinorTickSize.Width;
                        mr.Fill = new SolidColorBrush(MinorTickColor);
                        mr.HorizontalAlignment = HorizontalAlignment.Center;
                        mr.VerticalAlignment = VerticalAlignment.Center;
                        Point p1 = new Point(0.5, 0.5);
                        mr.RenderTransformOrigin = p1;

                        TransformGroup minortickgp = new TransformGroup();
                        RotateTransform minortickrt = new RotateTransform();
                        minortickrt.Angle = mi;
                        minortickgp.Children.Add(minortickrt);
                        TranslateTransform minorticktt = new TranslateTransform();

                        //Obtaining the angle in radians for calulating the points
                        Double mi_radian = (mi * Math.PI) / 180;
                        //Finding the point on the Scale where the minor ticks are drawn
                        minorticktt.X = (int)((ScaleRadius) * Math.Cos(mi_radian));
                        minorticktt.Y = (int)((ScaleRadius) * Math.Sin(mi_radian));

                        minortickgp.Children.Add(minorticktt);
                        mr.RenderTransform = minortickgp;
                        rootGrid.Children.Add(mr);


                    }

                }

            }
        }

<my:CircularGaugeControl x:Name="myGauge1" Radius="150"
                                ScaleRadius="110"
                                ScaleStartAngle="120"
                                ScaleSweepAngle="300"
                                PointerLength="85"
                                PointerCapRadius="35"
                                MinValue="0"
                                MaxValue="1000"
                                MajorDivisionsCount="10"
                                MinorDivisionsCount="5"
                                CurrentValue="{Binding Score}"
                                ImageSource="windowslogo.png"
                                ImageSize="40,50"
                                RangeIndicatorThickness="8"
                                RangeIndicatorRadius="120"
                                RangeIndicatorLightRadius="10"
                                RangeIndicatorLightOffset="80"
                                ScaleLabelRadius="90"
                                ScaleLabelSize="40,20"
                                ScaleLabelFontSize="10"
                                ScaleLabelForeground="LightGray"
                                MajorTickSize="10,3"
                                MinorTickSize="3,1"
                                MajorTickColor="LightGray"
                                MinorTickColor="LightGray"
                                ImageOffset="-50"
                                GaugeBackgroundColor="Black"
                                PointerThickness ="16"
                                OptimalRangeStartValue="300"
                                OptimalRangeEndValue="700"
                                DialTextOffset="40"
                                DialText="Black"
                                DialTextColor="Black" Margin="-46,-38,-42,-33">

</my:CircularGaugeControl>

CircularGauge.CircularGaugeControl.DrawRangeIndicator

//0g reset range to start @zero to eliminate the drawing problems            
//i.e. min=10, max=100, optimalStart = 70, OptimalEnd=80
//then reset values to min=0, max=90, optimalStart = 60, OptimalEnd=70 (subtracting the min value)
Double tmpMaxValue = (MaxValue - MinValue);                           //new max value (subtract the MinValue)
Double tmpStartValue = Math.Abs(OptimalRangeStartValue - MinValue);   //Start value is calculated from zero
Double tmpEndValue = Math.Abs(OptimalRangeEndValue - MinValue);       //End value is calculated from zero
            
//TODO replace the original variables with the temp calculation
Double realworldunit = (ScaleSweepAngle / tmpMaxValue);                                                     
Double optimalStartAngle = ((double)(tmpStartValue * realworldunit));
Double optimalEndAngle = ((double)(tmpEndValue * realworldunit));                     
//END OF TMP CALC CHANGES. REST OF CODE SHOULD BE OK

Test Cases:<br />
min,max,optimalStart, OptimalEnd<br />
-10,10,2,4<br />
-10,10,-5,-2<br />
32,41,33,35<br />
22000,38000,31600,34800

/// <summary>
/// Draw the range indicator
/// </summary>
private void DrawRangeIndicator()
{
    // FIX: http://www.codeproject.com/KB/silverlight/circulargaugecontrol.aspx?msg=3345458#xx3345458xx
    //0g reset range to start @zero to eliminate the drawing problems
    //i.e. min=10, max=100, optimalStart = 70, OptimalEnd=80
    //then reset values to min=0, max=90, optimalStart = 60, OptimalEnd=70 (subtracting the min value)
    Double tmpMaxValue = (MaxValue - MinValue);                           //new max value (subtract the MinValue)
    Double tmpStartValue = Math.Abs(OptimalRangeStartValue - MinValue);   //Start value is calculated from zero
    Double tmpEndValue = Math.Abs(OptimalRangeEndValue - MinValue);       //End value is calculated from zero
    //TODO replace the original variables with the temp calculation
    Double realworldunit = (ScaleSweepAngle / tmpMaxValue);
    Double optimalStartAngle = ((double)(tmpStartValue * realworldunit));
    Double optimalEndAngle = ((double)(tmpEndValue * realworldunit));
    //END OF TMP CALC CHANGES. REST OF CODE SHOULD BE OK
    double db;

    //Checking whether the  OptimalRangeStartvalue is -ve
    if (OptimalRangeStartValue < 0)
    {
        db = MinValue + Math.Abs(OptimalRangeStartValue);
        optimalStartAngle = ((double)(Math.Abs(db * realworldunit)));
    }
    else
    {
        db = Math.Abs(MinValue) + OptimalRangeStartValue;
        optimalStartAngle = ((double)(db * realworldunit));
    }

    //Checking whether the  OptimalRangeEndvalue is -ve
    if (OptimalRangeEndValue < 0)
    {
        db = MinValue + Math.Abs(OptimalRangeEndValue);
        optimalEndAngle = ((double)(Math.Abs(db * realworldunit)));
    }
    else
    {
        db = Math.Abs(MinValue) + OptimalRangeEndValue;
        optimalEndAngle = ((double)(db * realworldunit));
    }
    // calculating the angle for optimal Start value

    Double optimalStartAngleFromStart = (ScaleStartAngle + optimalStartAngle);

    // calculating the angle for optimal Start value

    Double optimalEndAngleFromStart = (ScaleStartAngle + optimalEndAngle);

    //Calculating the Radius of the two arc for segment
    arcradius1 = (RangeIndicatorRadius + RangeIndicatorThickness);
    arcradius2 = RangeIndicatorRadius;

    double endAngle = ScaleStartAngle + ScaleSweepAngle;

    // Calculating the Points for the below Optimal Range segment from the center of the gauge

    Point A = GetCircumferencePoint(ScaleStartAngle, arcradius1);
    Point B = GetCircumferencePoint(ScaleStartAngle, arcradius2);
    Point C = GetCircumferencePoint(optimalStartAngleFromStart, arcradius2);
    Point D = GetCircumferencePoint(optimalStartAngleFromStart, arcradius1);

    bool isReflexAngle = Math.Abs(optimalStartAngleFromStart - ScaleStartAngle) > 180.0;
    DrawSegment(A, B, C, D, isReflexAngle, BelowOptimalRangeColor);

    // Calculating the Points for the Optimal Range segment from the center of the gauge

    Point A1 = GetCircumferencePoint(optimalStartAngleFromStart, arcradius1);
    Point B1 = GetCircumferencePoint(optimalStartAngleFromStart, arcradius2);
    Point C1 = GetCircumferencePoint(optimalEndAngleFromStart, arcradius2);
    Point D1 = GetCircumferencePoint(optimalEndAngleFromStart, arcradius1);
    bool isReflexAngle1 = Math.Abs(optimalEndAngleFromStart - optimalStartAngleFromStart) > 180.0;
    DrawSegment(A1, B1, C1, D1, isReflexAngle1, OptimalRangeColor);

    // Calculating the Points for the Above Optimal Range segment from the center of the gauge

    Point A2 = GetCircumferencePoint(optimalEndAngleFromStart, arcradius1);
    Point B2 = GetCircumferencePoint(optimalEndAngleFromStart, arcradius2);
    Point C2 = GetCircumferencePoint(endAngle, arcradius2);
    Point D2 = GetCircumferencePoint(endAngle, arcradius1);
    bool isReflexAngle2 = Math.Abs(endAngle - optimalEndAngleFromStart) > 180.0;
    DrawSegment(A2, B2, C2, D2, isReflexAngle2, AboveOptimalRangeColor);
}

/// <summary>
/// Draw the range indicator
/// </summary>
private void DrawRangeIndicator()
{
    Double realworldunit = (ScaleSweepAngle / (MaxValue - MinValue));
    Double optimalStartAngle;
    Double optimalEndAngle;
    //double db;

    ////Checking whether the  OptimalRangeStartvalue is -ve
    //if (OptimalRangeStartValue < 0)
    //{
    //    db = MinValue + Math.Abs(OptimalRangeStartValue);
    //    optimalStartAngle = ((double)(Math.Abs(db * realworldunit)));
    //}
    //else
    //{
    //    db = Math.Abs(MinValue) + OptimalRangeStartValue;
    //    optimalStartAngle = ((double)(db * realworldunit));
    //}
    optimalStartAngle = realworldunit * (OptimalRangeStartValue - MinValue);

    ////Checking whether the  OptimalRangeEndvalue is -ve
    //if (OptimalRangeEndValue < 0)
    //{
    //    db = MinValue + Math.Abs(OptimalRangeEndValue);
    //    optimalEndAngle = ((double)(Math.Abs(db * realworldunit)));
    //}
    //else
    //{
    //    db = Math.Abs(MinValue) + OptimalRangeEndValue;
    //    optimalEndAngle = ((double)(db * realworldunit));
    //}
    // calculating the angle for optimal Start value
    optimalEndAngle = realworldunit * (OptimalRangeEndValue - MinValue);

    Double optimalStartAngleFromStart = (ScaleStartAngle + optimalStartAngle);

    // calculating the angle for optimal Start value

    Double optimalEndAngleFromStart = (ScaleStartAngle + optimalEndAngle);

    //Calculating the Radius of the two arc for segment
    arcradius1 = (RangeIndicatorRadius + RangeIndicatorThickness);
    arcradius2 = RangeIndicatorRadius;

    double endAngle = ScaleStartAngle + ScaleSweepAngle;

    // Calculating the Points for the below Optimal Range segment from the center of the gauge

    Point A = GetCircumferencePoint(ScaleStartAngle, arcradius1);
    Point B = GetCircumferencePoint(ScaleStartAngle, arcradius2);
    Point C = GetCircumferencePoint(optimalStartAngleFromStart, arcradius2);
    Point D = GetCircumferencePoint(optimalStartAngleFromStart, arcradius1);

    bool isReflexAngle = Math.Abs(optimalStartAngleFromStart - ScaleStartAngle) > 180.0;
    DrawSegment(A, B, C, D, isReflexAngle, BelowOptimalRangeColor);

    // Calculating the Points for the Optimal Range segment from the center of the gauge

    Point A1 = GetCircumferencePoint(optimalStartAngleFromStart, arcradius1);
    Point B1 = GetCircumferencePoint(optimalStartAngleFromStart, arcradius2);
    Point C1 = GetCircumferencePoint(optimalEndAngleFromStart, arcradius2);
    Point D1 = GetCircumferencePoint(optimalEndAngleFromStart, arcradius1);
    bool isReflexAngle1 = Math.Abs(optimalEndAngleFromStart - optimalStartAngleFromStart) > 180.0;
    DrawSegment(A1, B1, C1, D1, isReflexAngle1, OptimalRangeColor);

    // Calculating the Points for the Above Optimal Range segment from the center of the gauge

    Point A2 = GetCircumferencePoint(optimalEndAngleFromStart, arcradius1);
    Point B2 = GetCircumferencePoint(optimalEndAngleFromStart, arcradius2);
    Point C2 = GetCircumferencePoint(endAngle, arcradius2);
    Point D2 = GetCircumferencePoint(endAngle, arcradius1);
    bool isReflexAngle2 = Math.Abs(endAngle - optimalEndAngleFromStart) > 180.0;
    DrawSegment(A2, B2, C2, D2, isReflexAngle2, AboveOptimalRangeColor);
}

<gauge:CircularGaugeControl x:Name="myGauge1" Grid.Column="0" Grid.Row="0" Margin="5"
    Radius="75" 
        :        :
    PointerCapRadius="10" 
    MinValue="{Binding Minimum}" 
    MaxValue="{Binding Maximum}" 
    MajorDivisionsCount="10" 
        :        :
    PointerThickness ="10"
    OptimalRangeStartValue="{Binding OptimalRangeStart}"
    OptimalRangeEndValue="{Binding OptimalRangeEnd}" 
    DialTextOffset="20" 
    DialText="{Binding Units}"
    DialTextColor="Black"
    ></gauge:CircularGaugeControl>

DialText = newValue.ToString();

/// <summary>
/// Converts a value to an angle on the gauge.
/// </summary>
/// <param name="value">Value in range MinValue..MaxValue.</param>
/// <returns>Angle in range ScaleStartAngle..(ScaleStartAngle+ScaleSweepAngle).</returns>
private double ValueToAngle(double value)
{
    Double realworldunit = (ScaleSweepAngle / (MaxValue - MinValue));
    double equivalentAngle = ScaleStartAngle + (value - MinValue) * realworldunit;
    return equivalentAngle;

if (pointer != null)
{
    AnimatePointer(ValueToAngle(oldValue), ValueToAngle(newValue));
}

private void DrawRangeIndicator()
{
    // calculating the angle for optimal Start value
    Double optimalStartAngleFromStart = ValueToAngle(OptimalRangeStartValue);

    // calculating the angle for optimal Start value
    Double optimalEndAngleFromStart = ValueToAngle(OptimalRangeEndValue);

    //Calculating the Radius of the two arc for segment 
    arcradius1 = (RangeIndicatorRadius + RangeIndicatorThickness);
        :        :

public override void OnApplyTemplate()
{
    base.OnApplyTemplate();
        :        :
    Canvas.SetZIndex(pointerCap, 100001);

    //Set Pointer to initial value
    MovePointer(ScaleStartAngle);
    AnimatePointer(ScaleStartAngle, ValueToAngle(CurrentValue));
}