public void AlignToRight()
{
TextOutline outline = new TextOutline("Cl", font, emSize);
AtomSymbol symbol = new AtomSymbol(outline, Array.Empty <TextOutline>());
AssertCloseTo(outline.GetLastGlyphCenter(), symbol.AlignTo(Right).GetAlignmentCenter(), 0.01);
}
public void TestGetOutlines()
{
TextOutline outline = new TextOutline("Cl", font, emSize);
AtomSymbol symbol = new AtomSymbol(outline, Array.Empty <TextOutline>());
var outlineBounds = outline.GetOutline().Bounds;
var symbolBounds = symbol.GetOutlines()[0].Bounds;
Assert.AreEqual(symbolBounds.X, outlineBounds.X, 0.01);
Assert.AreEqual(symbolBounds.Y, outlineBounds.Y, 0.01);
Assert.AreEqual(symbolBounds.Left, outlineBounds.Left, 0.01);
Assert.AreEqual(symbolBounds.Bottom, outlineBounds.Bottom, 0.01);
}
public void TestGetOutlinesWithAdjunct()
{
TextOutline outline = new TextOutline("Cl", font, emSize);
TextOutline adjunct = new TextOutline("H", font, emSize);
AtomSymbol symbol = new AtomSymbol(outline, new[] { adjunct });
var outlineBounds = adjunct.GetOutline().Bounds;
var symbolBounds = symbol.GetOutlines()[1].Bounds;
Assert.AreEqual(symbolBounds.X, outlineBounds.X, 0.01);
Assert.AreEqual(symbolBounds.Y, outlineBounds.Y, 0.01);
Assert.AreEqual(symbolBounds.Left, outlineBounds.Left, 0.01);
Assert.AreEqual(symbolBounds.Bottom, outlineBounds.Bottom, 0.01);
}
public void TestTranslate()
{
TextOutline outline = new TextOutline("Cl", font, emSize);
AtomSymbol symbol = new AtomSymbol(outline, Array.Empty <TextOutline>());
AtomSymbol transformed = symbol.Translate(4, 2);
var orgBounds = symbol.GetOutlines()[0].Bounds;
var newBounds = transformed.GetOutlines()[0].Bounds;
Assert.AreEqual(orgBounds.X + 4, newBounds.X, 0.01);
Assert.AreEqual(orgBounds.Y + 2, newBounds.Y, 0.01);
Assert.AreEqual(orgBounds.Right + 4, newBounds.Right, 0.01);
Assert.AreEqual(orgBounds.Bottom + 2, newBounds.Bottom, 0.01);
}
public void TestResize()
{
TextOutline outline = new TextOutline("Cl", font, emSize);
AtomSymbol symbol = new AtomSymbol(outline, Array.Empty <TextOutline>());
AtomSymbol transformed = symbol.Resize(2, 2);
var orgBounds = outline.GetBounds();
var newBounds = transformed.GetOutlines()[0].Bounds;
Assert.AreEqual(orgBounds.Left - orgBounds.Width / 2, newBounds.Left, 0.01);
Assert.AreEqual(orgBounds.Top - orgBounds.Height / 2, newBounds.Top, 0.01);
Assert.AreEqual(orgBounds.Right + orgBounds.Width / 2, newBounds.Right, 0.01);
Assert.AreEqual(orgBounds.Bottom + orgBounds.Height / 2, newBounds.Bottom, 0.01);
}
public void TestGetConvexHull()
{
TextOutline outline = new TextOutline("Cl", font, emSize);
AtomSymbol symbol = new AtomSymbol(outline, Array.Empty <TextOutline>());
ConvexHull outlineHull = ConvexHull.OfShape(outline.GetOutline());
ConvexHull symbolHull = symbol.GetConvexHull();
var outlineBounds = outlineHull.Outline.Bounds;
var symbolBounds = symbolHull.Outline.Bounds;
Assert.AreEqual(symbolBounds.X, outlineBounds.X, 0.01);
Assert.AreEqual(symbolBounds.Y, outlineBounds.Y, 0.01);
Assert.AreEqual(symbolBounds.Left, outlineBounds.Left, 0.01);
Assert.AreEqual(symbolBounds.Bottom, outlineBounds.Bottom, 0.01);
}
public void TestCenter()
{
TextOutline outline = new TextOutline("Cl", font, emSize);
AtomSymbol symbol = new AtomSymbol(outline, Array.Empty <TextOutline>());
AtomSymbol transformed = symbol.Center(2, 2);
var oBounds = outline.GetBounds();
var newBounds = transformed.GetOutlines()[0].Bounds;
double dx = 2 - oBounds.CenterX();
double dy = 2 - oBounds.CenterY();
Assert.AreEqual(oBounds.Left + dx, newBounds.X, 0.01);
Assert.AreEqual(oBounds.Top + dy, newBounds.Y, 0.01);
Assert.AreEqual(oBounds.Right + dx, newBounds.Right, 0.01);
Assert.AreEqual(oBounds.Bottom + dy, newBounds.Bottom, 0.01);
}
/// <summary>
/// Generate an annotation 'label' for an atom (located at 'basePoint'). The label is offset from
/// the basePoint by the provided 'distance' and 'direction'.
/// </summary>
/// <param name="basePoint">the relative (0,0) reference</param>
/// <param name="label">the annotation text</param>
/// <param name="direction">the direction along which the label is laid out</param>
/// <param name="distance">the distance along the direct to travel</param>
/// <param name="scale">the font scale of the label</param>
/// <param name="font">the font to use</param>
/// <param name="symbol">the atom symbol to avoid overlap with</param>
/// <returns>the position text outline for the annotation</returns>
internal static TextOutline GenerateAnnotation(Vector2 basePoint, string label, Vector2 direction, double distance, double scale, Typeface font, double emSize, AtomSymbol symbol)
{
var italicHint = label.StartsWith(ItalicDisplayPrefix);
label = italicHint ? label.Substring(ItalicDisplayPrefix.Length) : label;
var annFont = italicHint ? new Typeface(font.FontFamily, WPF.FontStyles.Italic, font.Weight, font.Stretch) : font;
var annOutline = new TextOutline(label, annFont, emSize).Resize(scale, -scale);
// align to the first or last character of the annotation depending on the direction
var center = direction.X > 0.3 ? annOutline.GetFirstGlyphCenter() : direction.X < -0.3 ? annOutline.GetLastGlyphCenter() : annOutline.GetCenter();
// Avoid atom symbol
if (symbol != null)
{
var intersect = symbol.GetConvexHull().Intersect(VecmathUtil.ToPoint(basePoint), VecmathUtil.ToPoint(VecmathUtil.Sum(basePoint, direction)));
// intersect should never be null be check against this
if (intersect != null)
{
basePoint = VecmathUtil.ToVector(intersect);
}
}
direction *= distance;
direction += basePoint;
// move to position
return(annOutline.Translate(direction.X - center.X, direction.Y - center.Y));
}
/// <summary>
/// Generate the intermediate <see cref="AtomSymbol"/> instances.
/// </summary>
/// <param name="container">structure representation</param>
/// <param name="symbolRemap">use alternate symbols (used for Sgroup shortcuts)</param>
/// <param name="visibility">defines whether an atom symbol is displayed</param>
/// <param name="parameters">render model parameters</param>
/// <returns>generated atom symbols (can contain <see langword="null"/>)</returns>
private AtomSymbol[] GenerateAtomSymbols(IAtomContainer container,
Dictionary <IAtom, string> symbolRemap,
SymbolVisibility visibility,
RendererModel parameters,
ElementGroup annotations,
Color foreground,
double stroke,
StandardDonutGenerator donutGen)
{
var scale = parameters.GetScale();
var annDist = parameters.GetAnnotationDistance() * (parameters.GetBondLength() / scale);
var annScale = (1 / scale) * parameters.GetAnnotationFontScale();
var annColor = parameters.GetAnnotationColor();
var halfStroke = stroke / 2;
var symbols = new AtomSymbol[container.Atoms.Count];
var builder = container.Builder;
// check if we should annotate attachment point numbers (maxAttach>1)
// and queue them all up for processing
var attachPoints = new List <IPseudoAtom>();
int maxAttach = 0;
for (int i = 0; i < container.Atoms.Count; i++)
{
var atom = container.Atoms[i];
if (IsHiddenFully(atom))
{
continue;
}
if (atom is IPseudoAtom)
{
var attachNum = ((IPseudoAtom)atom).AttachPointNum;
if (attachNum > 0)
{
attachPoints.Add((IPseudoAtom)atom);
}
if (attachNum > maxAttach)
{
maxAttach = attachNum;
}
}
var remapped = symbolRemap.ContainsKey(atom);
var bonds = container.GetConnectedBonds(atom);
var neighbors = container.GetConnectedAtoms(atom);
var visNeighbors = new List <IAtom>();
// if a symbol is remapped we only want to consider
// visible neighbors in the alignment calculation, otherwise
// we include all neighbors
foreach (var neighbor in neighbors)
{
if (!remapped || !IsHidden(neighbor))
{
visNeighbors.Add(neighbor);
}
}
var auxVectors = new List <Vector2>(1);
// only generate if the symbol is visible
if (visibility.Visible(atom, bonds, parameters) || remapped)
{
var hPosition = HydrogenPositionTools.Position(atom, visNeighbors);
if (atom.ImplicitHydrogenCount != null && atom.ImplicitHydrogenCount > 0)
{
auxVectors.Add(hPosition.Vector());
}
if (remapped)
{
symbols[i] = atomGenerator.GenerateAbbreviatedSymbol(symbolRemap[atom], hPosition);
}
else if (donutGen.IsChargeDelocalised(atom))
{
var charge = atom.FormalCharge;
atom.FormalCharge = 0;
// can't think of a better way to handle this without API
// change to symbol visibility
if (atom.AtomicNumber != 6)
{
symbols[i] = atomGenerator.GenerateSymbol(container, atom, hPosition, parameters);
}
atom.FormalCharge = charge;
}
else
{
symbols[i] = atomGenerator.GenerateSymbol(container, atom, hPosition, parameters);
}
if (symbols[i] != null)
{
// defines how the element is aligned on the atom point, when
// aligned to the left, the first character 'e.g. Cl' is used.
if (visNeighbors.Count < 4)
{
if (hPosition == HydrogenPosition.Left)
{
symbols[i] = symbols[i].AlignTo(AtomSymbol.SymbolAlignment.Right);
}
else
{
symbols[i] = symbols[i].AlignTo(AtomSymbol.SymbolAlignment.Left);
}
}
var p = atom.Point2D;
if (p == null)
{
throw new ArgumentException("Atom did not have 2D coordinates");
}
symbols[i] = symbols[i].Resize(1 / scale, 1 / -scale).Center(p.Value.X, p.Value.Y);
}
}
var label = GetAnnotationLabel(atom);
if (label != null)
{
// to ensure consistent draw distance we need to adjust the annotation distance
// depending on whether we are drawing next to an atom symbol or not.
double strokeAdjust = symbols[i] != null ? -halfStroke : 0;
var vector = NewAtomAnnotationVector(atom, bonds, auxVectors);
var annOutline = GenerateAnnotation(atom.Point2D.Value, label, vector, annDist + strokeAdjust, annScale, font, emSize, symbols[i]);
// the AtomSymbol may migrate during bond generation and therefore the annotation
// needs to be tied to the symbol. If no symbol is available the annotation is
// fixed and we can add it to the annotation ElementGroup right away.
if (symbols[i] != null)
{
symbols[i] = symbols[i].AddAnnotation(annOutline);
}
else
{
annotations.Add(GeneralPath.ShapeOf(annOutline.GetOutline(), annColor));
}
}
}
// label attachment points
if (maxAttach > 1)
{
var attachNumOutlines = new List <TextOutline>();
double maxRadius = 0;
foreach (IPseudoAtom atom in attachPoints)
{
int attachNum = atom.AttachPointNum;
// to ensure consistent draw distance we need to adjust the annotation distance
// depending on whether we are drawing next to an atom symbol or not.
var strokeAdjust = -halfStroke;
var vector = NewAttachPointAnnotationVector(
atom,
container.GetConnectedBonds(atom),
new List <Vector2>());
var outline = GenerateAnnotation(atom.Point2D.Value,
attachNum.ToString(),
vector,
1.75 * annDist + strokeAdjust,
annScale,
new Typeface(font.FontFamily, font.Style, WPF.FontWeights.Bold, font.Stretch),
emSize,
null);
attachNumOutlines.Add(outline);
var w = outline.GetBounds().Width;
var h = outline.GetBounds().Height;
var r = Math.Sqrt(w * w + h * h) / 2;
if (r > maxRadius)
{
maxRadius = r;
}
}
foreach (var outline in attachNumOutlines)
{
var group = new ElementGroup();
var radius = 2 * stroke + maxRadius;
var shape = new EllipseGeometry(outline.GetCenter(), radius, radius);
var area1 = Geometry.Combine(shape, outline.GetOutline(), GeometryCombineMode.Exclude, Transform.Identity);
group.Add(GeneralPath.ShapeOf(area1, foreground));
annotations.Add(group);
}
}
return(symbols);
}
private IRenderingElement GenerateSgroupBrackets(Sgroup sgroup,
IList <SgroupBracket> brackets,
IReadOnlyDictionary <IAtom, AtomSymbol> symbols,
string subscriptSuffix,
string superscriptSuffix)
{
// brackets are square by default (style:0)
var style = (int?)sgroup.GetValue(SgroupKey.CtabBracketStyle);
bool round = style != null && style == 1;
ElementGroup result = new ElementGroup();
var atoms = sgroup.Atoms;
var crossingBonds = sgroup.Bonds;
// easy to depict in correct orientation, we just
// point each bracket at the atom of a crossing
// bond that is 'in' the group - this scales
// to more than two brackets
// first we need to pair the brackets with the bonds
var pairs = crossingBonds.Count == brackets.Count ? BracketBondPairs(brackets, crossingBonds) : Dictionaries.Empty <SgroupBracket, IBond>();
// override bracket layout around single atoms to bring them in closer
if (atoms.Count == 1)
{
IAtom atom = atoms.First();
// e.g. 2 HCL, 8 H2O etc.
if (IsUnsignedInt(subscriptSuffix) &&
!crossingBonds.Any() &&
symbols.ContainsKey(atom))
{
TextOutline prefix = new TextOutline('·' + subscriptSuffix, font, emSize).Resize(1 / scale, 1 / -scale);
Rect prefixBounds = prefix.LogicalBounds;
AtomSymbol symbol = symbols[atom];
Rect bounds = symbol.GetConvexHull().Outline.Bounds;
// make slightly large
bounds = new Rect(bounds.Bottom - 2 * stroke,
bounds.Left - 2 * stroke,
bounds.Width + 4 * stroke,
bounds.Height + 4 * stroke);
prefix = prefix.Translate(bounds.Bottom - prefixBounds.Top,
symbol.GetAlignmentCenter().Y - prefixBounds.CenterY());
result.Add(GeneralPath.ShapeOf(prefix.GetOutline(), foreground));
}
// e.g. CC(O)nCC
else if (crossingBonds.Count > 0)
{
double scriptscale = labelScale;
TextOutline leftBracket = new TextOutline("(", font, emSize).Resize(1 / scale, 1 / -scale);
TextOutline rightBracket = new TextOutline(")", font, emSize).Resize(1 / scale, 1 / -scale);
var leftCenter = leftBracket.GetCenter();
var rightCenter = rightBracket.GetCenter();
if (symbols.ContainsKey(atom))
{
AtomSymbol symbol = symbols[atom];
var bounds = symbol.GetConvexHull().Outline.Bounds;
// make slightly large
bounds = new Rect(bounds.Left - 2 * stroke,
bounds.Top - 2 * stroke,
bounds.Width + 4 * stroke,
bounds.Height + 4 * stroke);
leftBracket = leftBracket.Translate(bounds.Left - 0.1 - leftCenter.X,
symbol.GetAlignmentCenter().Y - leftCenter.Y);
rightBracket = rightBracket.Translate(bounds.Right + 0.1 - rightCenter.X,
symbol.GetAlignmentCenter().Y - rightCenter.Y);
}
else
{
Vector2 p = atoms.First().Point2D.Value;
leftBracket = leftBracket.Translate(p.X - 0.2 - leftCenter.X, p.Y - leftCenter.Y);
rightBracket = rightBracket.Translate(p.X + 0.2 - rightCenter.X, p.Y - rightCenter.Y);
}
result.Add(GeneralPath.ShapeOf(leftBracket.GetOutline(), foreground));
result.Add(GeneralPath.ShapeOf(rightBracket.GetOutline(), foreground));
var rightBracketBounds = rightBracket.GetBounds();
// subscript/superscript suffix annotation
if (subscriptSuffix != null && subscriptSuffix.Any())
{
TextOutline subscriptOutline = LeftAlign(MakeText(subscriptSuffix.ToLowerInvariant(),
new Vector2(rightBracketBounds.Right,
rightBracketBounds.Top - 0.1),
new Vector2(-0.5 * rightBracketBounds.Width, 0),
scriptscale));
result.Add(GeneralPath.ShapeOf(subscriptOutline.GetOutline(), foreground));
}
if (superscriptSuffix != null && superscriptSuffix.Any())
{
TextOutline superscriptOutline = LeftAlign(MakeText(superscriptSuffix.ToLowerInvariant(),
new Vector2(rightBracketBounds.Right,
rightBracketBounds.Bottom + 0.1),
new Vector2(-rightBracketBounds.Width, 0),
scriptscale));
result.Add(GeneralPath.ShapeOf(superscriptOutline.GetOutline(), foreground));
}
}
}
else if (pairs.Any())
{
SgroupBracket suffixBracket = null;
Vector2? suffixBracketPerp = null;
foreach (var e in pairs)
{
var bracket = e.Key;
var bond = e.Value;
var inGroupAtom = atoms.Contains(bond.Begin) ? bond.Begin : bond.End;
var p1 = bracket.FirstPoint;
var p2 = bracket.SecondPoint;
var perp = VecmathUtil.NewPerpendicularVector(VecmathUtil.NewUnitVector(p1, p2));
// point the vector at the atom group
Vector2 midpoint = VecmathUtil.Midpoint(p1, p2);
if (Vector2.Dot(perp, VecmathUtil.NewUnitVector(midpoint, inGroupAtom.Point2D.Value)) < 0)
{
perp = Vector2.Negate(perp);
}
perp *= bracketDepth;
if (round)
{
result.Add(CreateRoundBracket(p1, p2, perp, midpoint));
}
else
{
result.Add(CreateSquareBracket(p1, p2, perp));
}
if (suffixBracket == null)
{
suffixBracket = bracket;
suffixBracketPerp = perp;
}
else
{
// is this bracket better as a suffix?
Vector2 sp1 = suffixBracket.FirstPoint;
Vector2 sp2 = suffixBracket.SecondPoint;
double bestMaxX = Math.Max(sp1.X, sp2.X);
double thisMaxX = Math.Max(p1.X, p2.X);
double bestMaxY = Math.Max(sp1.Y, sp2.Y);
double thisMaxY = Math.Max(p1.Y, p2.Y);
// choose the most eastern or.. the most southern
double xDiff = thisMaxX - bestMaxX;
double yDiff = thisMaxY - bestMaxY;
if (xDiff > EQUIV_THRESHOLD || (xDiff > -EQUIV_THRESHOLD && yDiff < -EQUIV_THRESHOLD))
{
suffixBracket = bracket;
suffixBracketPerp = perp;
}
}
}
// write the labels
if (suffixBracket != null)
{
Vector2 subSufPnt = suffixBracket.FirstPoint;
Vector2 supSufPnt = suffixBracket.SecondPoint;
// try to put the subscript on the bottom
double xDiff = subSufPnt.X - supSufPnt.X;
double yDiff = subSufPnt.Y - supSufPnt.Y;
if (yDiff > EQUIV_THRESHOLD || (yDiff > -EQUIV_THRESHOLD && xDiff > EQUIV_THRESHOLD))
{
Vector2 tmpP = subSufPnt;
subSufPnt = supSufPnt;
supSufPnt = tmpP;
}
// subscript/superscript suffix annotation
if (subscriptSuffix != null && subscriptSuffix.Any())
{
TextOutline subscriptOutline = LeftAlign(MakeText(subscriptSuffix.ToLowerInvariant(), subSufPnt, suffixBracketPerp.Value, labelScale));
result.Add(GeneralPath.ShapeOf(subscriptOutline.GetOutline(), foreground));
}
if (superscriptSuffix != null && superscriptSuffix.Any())
{
TextOutline superscriptOutline = LeftAlign(MakeText(superscriptSuffix.ToLowerInvariant(), supSufPnt, suffixBracketPerp.Value, labelScale));
result.Add(GeneralPath.ShapeOf(superscriptOutline.GetOutline(), foreground));
}
}
}
else if (brackets.Count == 2)
{
var b1p1 = brackets[0].FirstPoint;
var b1p2 = brackets[0].SecondPoint;
var b2p1 = brackets[1].FirstPoint;
var b2p2 = brackets[1].SecondPoint;
var b1vec = VecmathUtil.NewUnitVector(b1p1, b1p2);
var b2vec = VecmathUtil.NewUnitVector(b2p1, b2p2);
var b1pvec = VecmathUtil.NewPerpendicularVector(b1vec);
var b2pvec = VecmathUtil.NewPerpendicularVector(b2vec);
// Point the vectors at each other
if (Vector2.Dot(b1pvec, VecmathUtil.NewUnitVector(b1p1, b2p1)) < 0)
{
b1pvec = Vector2.Negate(b1pvec);
}
if (Vector2.Dot(b2pvec, VecmathUtil.NewUnitVector(b2p1, b1p1)) < 0)
{
b2pvec = Vector2.Negate(b2pvec);
}
// scale perpendicular vectors by how deep the brackets need to be
b1pvec *= bracketDepth;
b2pvec *= bracketDepth;
// bad brackets
if (double.IsNaN(b1pvec.X) || double.IsNaN(b1pvec.Y) ||
double.IsNaN(b2pvec.X) || double.IsNaN(b2pvec.Y))
{
return(result);
}
{
var path = new PathGeometry();
if (round)
{
{
// bracket 1 (cp: control point)
var pf = new PathFigure
{
StartPoint = new Point(b1p1.X + b1pvec.X, b1p1.Y + b1pvec.Y)
};
Vector2 cpb1 = VecmathUtil.Midpoint(b1p1, b1p2);
cpb1 += VecmathUtil.Negate(b1pvec);
var seg = new QuadraticBezierSegment
{
Point1 = new Point(cpb1.X, cpb1.Y),
Point2 = new Point(b1p2.X + b1pvec.X, b1p2.Y + b1pvec.Y)
};
pf.Segments.Add(seg);
path.Figures.Add(pf);
}
{
// bracket 2 (cp: control point)
var pf = new PathFigure
{
StartPoint = new Point(b2p1.X + b2pvec.X, b2p1.Y + b2pvec.Y)
};
Vector2 cpb2 = VecmathUtil.Midpoint(b2p1, b2p2);
cpb2 += VecmathUtil.Negate(b2pvec);
var seg = new QuadraticBezierSegment
{
Point1 = new Point(cpb2.X, cpb2.Y),
Point2 = new Point(b2p2.X + b2pvec.X, b2p2.Y + b2pvec.Y)
};
pf.Segments.Add(seg);
path.Figures.Add(pf);
}
}
else
{
{
// bracket 1
var pf = new PathFigure
{
StartPoint = new Point(b1p1.X + b1pvec.X, b1p1.Y + b1pvec.Y)
};
var seg = new PolyLineSegment();
seg.Points.Add(new Point(b1p1.X, b1p1.Y));
seg.Points.Add(new Point(b1p2.X, b1p2.Y));
seg.Points.Add(new Point(b1p2.X + b1pvec.X, b1p2.Y + b1pvec.Y));
pf.Segments.Add(seg);
path.Figures.Add(pf);
}
{
// bracket 2
var pf = new PathFigure
{
StartPoint = new Point(b2p1.X + b2pvec.X, b2p1.Y + b2pvec.Y)
};
var seg = new PolyLineSegment();
seg.Points.Add(new Point(b2p1.X, b2p1.Y));
seg.Points.Add(new Point(b2p2.X, b2p2.Y));
seg.Points.Add(new Point(b2p2.X + b2pvec.X, b2p2.Y + b2pvec.Y));
pf.Segments.Add(seg);
path.Figures.Add(pf);
}
}
result.Add(GeneralPath.OutlineOf(path, stroke, foreground));
}
// work out where to put the suffix labels (e.g. ht/hh/eu) superscript
// and (e.g. n, xl, c, mix) subscript
// TODO: could be improved
double b1MaxX = Math.Max(b1p1.X, b1p2.X);
double b2MaxX = Math.Max(b2p1.X, b2p2.X);
double b1MaxY = Math.Max(b1p1.Y, b1p2.Y);
double b2MaxY = Math.Max(b2p1.Y, b2p2.Y);
Vector2 subSufPnt = b2p2;
Vector2 supSufPnt = b2p1;
Vector2 subpvec = b2pvec;
double bXDiff = b1MaxX - b2MaxX;
double bYDiff = b1MaxY - b2MaxY;
if (bXDiff > EQUIV_THRESHOLD || (bXDiff > -EQUIV_THRESHOLD && bYDiff < -EQUIV_THRESHOLD))
{
subSufPnt = b1p2;
supSufPnt = b1p1;
subpvec = b1pvec;
}
double xDiff = subSufPnt.X - supSufPnt.X;
double yDiff = subSufPnt.Y - supSufPnt.Y;
if (yDiff > EQUIV_THRESHOLD || (yDiff > -EQUIV_THRESHOLD && xDiff > EQUIV_THRESHOLD))
{
Vector2 tmpP = subSufPnt;
subSufPnt = supSufPnt;
supSufPnt = tmpP;
}
// subscript/superscript suffix annotation
if (subscriptSuffix != null && subscriptSuffix.Any())
{
TextOutline subscriptOutline = LeftAlign(MakeText(subscriptSuffix.ToLowerInvariant(), subSufPnt, subpvec, labelScale));
result.Add(GeneralPath.ShapeOf(subscriptOutline.GetOutline(), foreground));
}
if (superscriptSuffix != null && superscriptSuffix.Any())
{
TextOutline superscriptOutline = LeftAlign(MakeText(superscriptSuffix.ToLowerInvariant(), supSufPnt, subpvec, labelScale));
result.Add(GeneralPath.ShapeOf(superscriptOutline.GetOutline(), foreground));
}
}
return(result);
}