public ImageInfo RenderSPTG(String symbolID, Dictionary <int, String> modifiers, Dictionary <int, String> attributes)
        {
            if (modifiers == null)
            {
                modifiers = new Dictionary <int, string>();
            }
            if (attributes == null)
            {
                attributes = new Dictionary <int, string>();
            }
            Bitmap finalBmp = null;

            Bitmap coreBMP = null;

            try
            {
                //Graphics g = Graphics.FromImage(dimensionsBMP);

                //get unit font
                Font spFont = _spFont;

                //get font character indexes
                int fillIndex  = -1;
                int frameIndex = -1;

                int alpha = 255;

                int     symbolOutlineSize  = 0;
                Color   symbolOutlineColor = Color.Empty;
                Boolean drawAsIcon         = false;
                Boolean keepUnitRatio      = true;
                int     pixelSize          = 35;
                int     w = pixelSize;
                int     h = pixelSize;

                char[] fillString  = new char[1];
                char[] frameString = new char[1];
                char[] symbol1     = new char[1];
                char[] symbol2     = new char[1];


                //_spFontSize;
                Color lineColor = Color.Empty;
                Color fillColor = Color.Empty;

                if (attributes.ContainsKey(MilStdAttributes.LineColor))
                {
                    lineColor = SymbolUtilities.getColorFromHexString(attributes[MilStdAttributes.LineColor]);
                }
                else
                {
                    lineColor = SymbolUtilities.getLineColorOfAffiliation(symbolID);
                }

                if (attributes.ContainsKey(MilStdAttributes.FillColor))
                {
                    fillColor = SymbolUtilities.getColorFromHexString(attributes[MilStdAttributes.FillColor]);
                }

                if (attributes.ContainsKey(MilStdAttributes.Alpha))
                {
                    alpha = Convert.ToInt32(attributes[MilStdAttributes.Alpha]);
                }

                /*if (attributes.ContainsKey(MilStdAttributes.SymbolOutlineColor))
                 *  symbolOutlineColor = SymbolUtilities.getColorFromHexString(attributes[MilStdAttributes.SymbolOutlineColor]);
                 * else
                 *  symbolOutlineColor = RenderUtilities.getIdealTextBackgroundColor(lineColor);
                 *
                 * if (attributes.ContainsKey(MilStdAttributes.SymbolOutlineSize))
                 *  symbolOutlineSize = Convert.ToInt32(attributes[MilStdAttributes.SymbolOutlineSize]);
                 * else
                 *  symbolOutlineSize = RendererSettings.getInstance().getSymbolOutlineWidth();//*/

                symbolOutlineColor = RendererUtilities.getIdealOutlineColor(lineColor);
                symbolOutlineSize  = RendererSettings.getInstance().getSymbolOutlineWidth();

                if (symbolOutlineSize <= 0)
                {
                    symbolOutlineColor = Color.Empty;
                }

                if (attributes.ContainsKey(MilStdAttributes.DrawAsIcon))
                {
                    drawAsIcon = Convert.ToBoolean(attributes[MilStdAttributes.DrawAsIcon]);
                }

                if (attributes.ContainsKey(MilStdAttributes.PixelSize))
                {
                    pixelSize = Convert.ToInt32(attributes[MilStdAttributes.PixelSize]);
                }

                if (attributes.ContainsKey(MilStdAttributes.KeepUnitRatio))
                {
                    keepUnitRatio = Convert.ToBoolean(attributes[MilStdAttributes.KeepUnitRatio]);
                }

                SinglePointLookupInfo spli = SinglePointLookup.getInstance().getSPLookupInfo(SymbolUtilities.getBasicSymbolID(symbolID));

                if (spli == null)//default to action point on bad symbolID
                {
                    if (modifiers == null)
                    {
                        modifiers = new Dictionary <int, String>();
                    }
                    if (modifiers.ContainsKey(ModifiersTG.H_ADDITIONAL_INFO_1))
                    {
                        modifiers[ModifiersTG.H1_ADDITIONAL_INFO_2] = modifiers[ModifiersTG.H_ADDITIONAL_INFO_1];
                    }
                    modifiers[ModifiersTG.H_ADDITIONAL_INFO_1] = symbolID.Substring(0, 10);

                    symbolID = "G" + SymbolUtilities.getAffiliation(symbolID) +
                               "G" + SymbolUtilities.getStatus(symbolID) + "GPP---****X";
                    spli      = SinglePointLookup.getInstance().getSPLookupInfo(symbolID);
                    lineColor = SymbolUtilities.getLineColorOfAffiliation(symbolID);
                    //fillColor = SymbolUtilities.getFillColorOfAffiliation(symbolID);
                }

                //Check if we need to set 'N' to ENY

                if (symbolID[1] == 'H' && drawAsIcon == false)
                {
                    if (modifiers == null)
                    {
                        modifiers = new Dictionary <int, string>();
                    }
                    modifiers[ModifiersTG.N_HOSTILE] = "ENY";
                }

                if (SymbolUtilities.getStatus(symbolID) == "A")
                {
                    frameIndex = spli.getMappingA();
                }
                else
                {
                    frameIndex = spli.getMappingP();
                }

                if (SymbolUtilities.hasDefaultFill(symbolID))
                {
                    fillColor = SymbolUtilities.getFillColorOfAffiliation(symbolID);
                }
                if (SymbolUtilities.isTGSPWithFill(symbolID))
                {
                    String fillID = SymbolUtilities.getTGFillSymbolCode(symbolID);
                    if (fillID != null)
                    {
                        fillIndex = SinglePointLookup.getInstance().getCharCodeFromFillID(fillID);
                    }
                }
                else if (SymbolUtilities.isWeatherSPWithFill(symbolID))
                {
                    fillIndex = frameIndex + 1;
                    fillColor = SymbolUtilities.getFillColorOfWeather(symbolID);
                }


                fillString[0]  = (char)fillIndex;
                frameString[0] = (char)frameIndex;


                SVGPath svgFill  = null;
                SVGPath svgFrame = null;

                if (fillIndex > 0)
                {
                    svgFill = SymbolSVGTable.getInstance().getSVGPath(fillIndex);
                }
                if (frameIndex > 0)
                {
                    svgFrame = SymbolSVGTable.getInstance().getSVGPath(frameIndex);
                }

                float      scale = 1;
                RectangleF rr    = svgFrame.getBounds();

                if (keepUnitRatio)
                {
                    scale = pixelSize * .00095f;
                    if (rr.Height > rr.Width)
                    {
                        pixelSize = (int)((scale * rr.Height) + 0.5);
                    }
                    else
                    {
                        pixelSize = (int)((scale * rr.Width) + 0.5);
                    }
                }


                Matrix m = svgFrame.TransformToFitDimensions(pixelSize, pixelSize);
                //Matrix m = svgFrame.TransformToFitDimensions(w, h);
                rr = svgFrame.getBounds();
                w  = (int)((rr.Width) + 0.5f);
                h  = (int)((rr.Height) + 0.5f);
                //draw location
                PointF centerPoint = SymbolDimensions.getSymbolCenter(spli.getBasicSymbolID(), rr);
                PointF location    = new PointF(0, 0);

                location.X = centerPoint.X;
                location.Y = 0;// centerPoint.Y;
                //location.Y = (h * 1.5f);

                float  outlineOffsetX = 0;
                float  outlineOffsetY = 0;
                Matrix mOutline       = new Matrix();
                if (symbolOutlineSize > 0)
                {
                    RectangleF rectOutline = svgFrame.getBounds(symbolOutlineSize);
                    outlineOffsetX = (rectOutline.Width - w) / 2f - 1;
                    outlineOffsetY = (rectOutline.Height - h) / 2f - 1;//too much added for AA
                    w = (int)(rectOutline.Width + 0.5f);
                    h = (int)(rectOutline.Height + 0.5f);
                    mOutline.Translate(outlineOffsetX, outlineOffsetY);
                    centerPoint.X += outlineOffsetX;
                    centerPoint.Y += outlineOffsetY;
                    coreBMP        = new Bitmap(w - 1, h - 1);//getBounds adds too much for AA
                }
                else
                {
                    coreBMP = new Bitmap(w + 1, h + 1);//add for AA
                }
                //coreBMP = new Bitmap(w, h);

                //get & setup graphics object for destination BMP
                Graphics g = Graphics.FromImage(coreBMP);


                g.SmoothingMode     = SmoothingMode.AntiAlias;
                g.TextRenderingHint = System.Drawing.Text.TextRenderingHint.AntiAlias;

                //draw test outline
                //g.DrawRectangle(new Pen(Color.LightSkyBlue), 0, 0, coreBMP.Width - 1, coreBMP.Height - 1);

                if (svgFill != null)
                {
                    svgFill.Transform(m);
                    svgFill.Draw(g, Color.Empty, 0, fillColor, mOutline);
                }

                if (svgFrame != null)
                {
                    svgFrame.Draw(g, symbolOutlineColor, symbolOutlineSize, lineColor, mOutline);
                }



                RectangleF coreDimensions = new RectangleF(0, 0, coreBMP.Width, coreBMP.Height);

                ImageInfo ii = new ImageInfo(coreBMP, new PointF(centerPoint.X, centerPoint.Y), coreDimensions);

                //process display modifiers
                ImageInfo iinew = null;

                Boolean   hasDisplayModifiers = ModifierRenderer.hasDisplayModifiers(symbolID, modifiers);
                Boolean   hasTextModifiers    = ModifierRenderer.hasTextModifiers(symbolID, modifiers, attributes);
                ImageInfo iiNew = null;

                if (drawAsIcon == false && (hasTextModifiers || hasDisplayModifiers || SymbolUtilities.isTGSPWithIntegralText(symbolID)))
                {
                    if (SymbolUtilities.isTGSPWithSpecialModifierLayout(symbolID) ||
                        SymbolUtilities.isTGSPWithIntegralText(symbolID))
                    {
                        iiNew = ModifierRenderer.ProcessTGSPWithSpecialModifierLayout(ii, symbolID, modifiers, attributes, lineColor);
                    }
                    else
                    {
                        iiNew = ModifierRenderer.ProcessTGSPModifiers(ii, symbolID, modifiers, attributes, lineColor);
                    }
                }

                if (iiNew != null)
                {
                    ii = iiNew;
                }

                iinew = null;

                g.Dispose();
                g = null;

                return(ii);
            }
            catch (Exception exc)
            {
                ErrorLogger.LogException("SinglePointRenderer", "RenderSPTG", exc);
                return(null);
            }
        }
        public ImageInfo RenderSPTG(String symbolID, Dictionary <int, String> modifiers, Dictionary <int, String> attributes)
        {
            if (modifiers == null)
            {
                modifiers = new Dictionary <int, string>();
            }
            if (attributes == null)
            {
                attributes = new Dictionary <int, string>();
            }
            CanvasRenderTarget finalBmp = null;

            CanvasRenderTarget coreBMP = null;

            try
            {
                //get font character indexes (svg file for this renderer port)
                int fillIndex  = -1;
                int frameIndex = -1;

                int alpha = 255;

                int     symbolOutlineSize  = 0;
                Color   symbolOutlineColor = Colors.Transparent;
                Boolean drawAsIcon         = false;
                Boolean keepUnitRatio      = true;
                int     pixelSize          = 35;
                int     w = pixelSize;
                int     h = pixelSize;

                char[] fillString  = new char[1];
                char[] frameString = new char[1];
                char[] symbol1     = new char[1];
                char[] symbol2     = new char[1];


                //_spFontSize;
                Color lineColor = Colors.Transparent;
                Color fillColor = Colors.Transparent;

                if (attributes.ContainsKey(MilStdAttributes.LineColor))
                {
                    lineColor = RenderUtilities.DrawingColorToUIColor(SymbolUtilities.getColorFromHexString(attributes[MilStdAttributes.LineColor]));
                }
                else
                {
                    lineColor = RenderUtilities.DrawingColorToUIColor(SymbolUtilities.getLineColorOfAffiliation(symbolID));
                }

                if (attributes.ContainsKey(MilStdAttributes.FillColor))
                {
                    fillColor = RenderUtilities.DrawingColorToUIColor(SymbolUtilities.getColorFromHexString(attributes[MilStdAttributes.FillColor]));
                }

                if (attributes.ContainsKey(MilStdAttributes.Alpha))
                {
                    alpha = Convert.ToInt32(attributes[MilStdAttributes.Alpha]);
                }

                if (attributes.ContainsKey(MilStdAttributes.SymbolOutlineColor))
                {
                    symbolOutlineColor = RenderUtilities.DrawingColorToUIColor(SymbolUtilities.getColorFromHexString(attributes[MilStdAttributes.SymbolOutlineColor]));
                }
                else
                {
                    symbolOutlineColor = RenderUtilities.getIdealTextBackgroundColor(lineColor);
                }

                if (attributes.ContainsKey(MilStdAttributes.SymbolOutlineSize))
                {
                    symbolOutlineSize = Convert.ToInt32(attributes[MilStdAttributes.SymbolOutlineSize]);
                }
                else
                {
                    symbolOutlineSize = RendererSettings.getInstance().getSymbolOutlineWidth();
                }

                if (symbolOutlineSize <= 0)
                {
                    symbolOutlineColor = Colors.Transparent;
                }

                if (attributes.ContainsKey(MilStdAttributes.DrawAsIcon))
                {
                    drawAsIcon = Convert.ToBoolean(attributes[MilStdAttributes.DrawAsIcon]);
                }

                if (attributes.ContainsKey(MilStdAttributes.PixelSize))
                {
                    pixelSize = Convert.ToInt32(attributes[MilStdAttributes.PixelSize]);
                }

                if (attributes.ContainsKey(MilStdAttributes.KeepUnitRatio))
                {
                    keepUnitRatio = Convert.ToBoolean(attributes[MilStdAttributes.KeepUnitRatio]);
                }

                SinglePointLookupInfo spli = SinglePointLookup.getInstance().getSPLookupInfo(SymbolUtilities.getBasicSymbolIDStrict(symbolID));

                if (spli == null)//default to action point on bad symbolID
                {
                    if (modifiers == null)
                    {
                        modifiers = new Dictionary <int, string>();
                    }
                    if (modifiers.ContainsKey(ModifiersTG.H_ADDITIONAL_INFO_1))
                    {
                        modifiers[ModifiersTG.H1_ADDITIONAL_INFO_2] = modifiers[ModifiersTG.H_ADDITIONAL_INFO_1];
                    }
                    modifiers[ModifiersTG.H_ADDITIONAL_INFO_1] = symbolID.Substring(0, 10);

                    symbolID = "G" + SymbolUtilities.getAffiliation(symbolID) +
                               "G" + SymbolUtilities.getStatus(symbolID) + "GPP---****X";
                    spli      = SinglePointLookup.getInstance().getSPLookupInfo(symbolID);
                    lineColor = RenderUtilities.DrawingColorToUIColor(SymbolUtilities.getLineColorOfAffiliation(symbolID));
                    //fillColor = SymbolUtilities.getFillColorOfAffiliation(symbolID);
                }

                //Check if we need to set 'N' to ENY

                if (symbolID[1] == 'H' && drawAsIcon == false)
                {
                    if (modifiers == null)
                    {
                        modifiers = new Dictionary <int, string>();
                    }
                    modifiers[ModifiersTG.N_HOSTILE] = "ENY";
                }

                if (SymbolUtilities.getStatus(symbolID) == "A")
                {
                    frameIndex = spli.getMappingA();
                }
                else
                {
                    frameIndex = spli.getMappingP();
                }

                if (SymbolUtilities.isTGSPWithFill(symbolID))
                {
                    String fillID = SymbolUtilities.getTGFillSymbolCode(symbolID);
                    if (fillID != null)
                    {
                        fillIndex = SinglePointLookup.getInstance().getCharCodeFromFillID(fillID);
                    }
                }
                else if (SymbolUtilities.isWeatherSPWithFill(symbolID))
                {
                    fillIndex = frameIndex + 1;
                    fillColor = RenderUtilities.DrawingColorToUIColor(SymbolUtilities.getFillColorOfWeather(symbolID));
                }


                fillString[0]  = (char)fillIndex;
                frameString[0] = (char)frameIndex;


                SVGPath svgFill  = null;
                SVGPath svgFrame = null;

                if (fillIndex > 0)
                {
                    svgFill = SymbolSVGTable.getInstance().getSVGPath(fillIndex);
                }
                if (frameIndex > 0)
                {
                    svgFrame = SymbolSVGTable.getInstance().getSVGPath(frameIndex);
                }

                float scale = 1;
                Rect  rr    = svgFrame.getBounds();

                if (keepUnitRatio)
                {
                    //scale = pixelSize * .00095f;// 1f;
                    scale = pixelSize / 34f;//height of friendly unit before scaling.
                    if (rr.Height > rr.Width)
                    {
                        pixelSize = (int)((scale * rr.Height) + 0.5);
                    }
                    else
                    {
                        pixelSize = (int)((scale * rr.Width) + 0.5);
                    }
                }

                Matrix3x2 mScale, mTranslate;
                Matrix3x2 mIdentity = Matrix3x2.Identity;
                Rect      rectF     = new Rect();
                Matrix3x2 m         = svgFrame.CreateMatrix(pixelSize, pixelSize, out rectF, out mScale, out mTranslate);
                //Matrix3x2 m = svgFrame.TransformToFitDimensions(pixelSize, pixelSize);

                rr = svgFrame.computeBounds(m);
                w  = (int)((rr.Width) + 0.5f);
                h  = (int)((rr.Height) + 0.5f);
                //draw location

                System.Drawing.RectangleF sdrr = new System.Drawing.RectangleF((float)rr.X, (float)rr.Y, (float)rr.Width, (float)rr.Height);
                System.Drawing.PointF     sdpf = SymbolDimensions.getSymbolCenter(spli.getBasicSymbolID(), sdrr);
                Point centerPoint = new Point(sdpf.X, sdpf.Y);
                Point location    = new Point(0, 0);

                location.X = centerPoint.X;
                location.Y = 0;// centerPoint.Y;
                //location.Y = (h * 1.5f);

                float     outlineOffsetX = 0;
                float     outlineOffsetY = 0;
                Matrix3x2 mOutline       = new Matrix3x2();

                CanvasDevice device = CanvasDevice.GetSharedDevice();
                //CanvasRenderTarget offscreen = new CanvasRenderTarget(device, width, height, 96);

                if (symbolOutlineSize > 0)
                {
                    Rect rectOutline = ShapeUtilities.inflate(rr, symbolOutlineSize, symbolOutlineSize); // svgFrame.getBounds(symbolOutlineSize);
                    outlineOffsetX = (float)((rectOutline.Width - w) / 2f);
                    outlineOffsetY = (float)((rectOutline.Height - h) / 2f);                             //too much added for AA
                    w              = (int)(rectOutline.Width + 0.5f);
                    h              = (int)(rectOutline.Height + 0.5f);
                    mOutline       = Matrix3x2.CreateTranslation(outlineOffsetX, outlineOffsetY);
                    centerPoint.X += outlineOffsetX;
                    centerPoint.Y += outlineOffsetY;
                    coreBMP        = new CanvasRenderTarget(device, w, h, 96);// new Bitmap(w, h);//getBounds adds too much for AA
                }
                else
                {
                    coreBMP = new CanvasRenderTarget(device, w, h, 96);//add for AA
                }
                //coreBMP = new Bitmap(w, h);

                //draw test outline
                //g.DrawRectangle(new Pen(Color.LightSkyBlue), 0, 0, coreBMP.Width - 1, coreBMP.Height - 1);
                using (CanvasDrawingSession cds = coreBMP.CreateDrawingSession())
                {
                    if (svgFill != null)
                    {
                        svgFill.Transform(m);
                        svgFill.Draw(cds, Colors.Transparent, 0, fillColor, mOutline);
                    }

                    if (svgFrame != null)
                    {
                        svgFrame.Transform(m);
                        svgFrame.Draw(cds, symbolOutlineColor, symbolOutlineSize, lineColor, mOutline);
                    }


                    cds.DrawRectangle(new Rect(0, 0, (int)(coreBMP.Size.Width + 0.5f), (int)(coreBMP.Size.Height + 0.5f)), Colors.Red);
                }


                Rect coreDimensions = new Rect(0, 0, (int)(coreBMP.Size.Width + 0.5f), (int)(coreBMP.Size.Height + 0.5f));

                ImageInfo ii = new ImageInfo(coreBMP, centerPoint, coreDimensions, coreBMP.GetBounds(device));

                //process display modifiers
                Boolean   hasDisplayModifiers = ModifierRenderer.hasDisplayModifiers(symbolID, modifiers);
                Boolean   hasTextModifiers    = ModifierRenderer.hasTextModifiers(symbolID, modifiers, attributes);
                ImageInfo iinew = null;

                if (hasDisplayModifiers)
                {
                    //iinew = ModifierRenderer.ProcessUnitDisplayModifiers(symbolID, ii, modifiers, attributes, true, device);
                }//*/

                if (iinew != null)
                {
                    ii = iinew;
                }
                iinew = null;

                //process text modifiers

                /*if (hasTextModifiers)
                 * {
                 *  //iinew = ModifierRenderer.ProcessUnitTextModifiers(symbolID, ii, modifiers, attributes);
                 *  iinew = ModifierRenderer.ProcessUnitTextModifiers(ii, symbolID, modifiers, attributes);
                 * }//*/

                if (iinew != null)
                {
                    ii = iinew;
                }
                iinew = null;

                /*if (coreBMP != null)
                 * {
                 *  coreBMP.Dispose();
                 *  coreBMP = null;
                 * }//*/

                return(ii);
            }
            catch (Exception exc)
            {
                ErrorLogger.LogException("SinglePointRenderer", "RenderSPTG", exc);
                return(null);
            }
        }