/// <summary> Constructs an Atom from a String containing an element symbol.
///
/// </summary>
/// <param name="elementSymbol"> The String describing the element for the Atom
/// </param>
public Atom(System.String elementSymbol)
: base(elementSymbol)
{
this.fractionalPoint3d = null;
this.point3d = null;
this.point2d = null;
}
/// <summary> Constructs an Atom from a String containing an element symbol.
///
/// </summary>
/// <param name="elementSymbol"> The String describing the element for the Atom
/// </param>
public Atom(System.String elementSymbol)
: base(elementSymbol)
{
this.fractionalPoint3d = null;
this.point3d = null;
this.point2d = null;
}
/// <summary> Constructs an Atom from an Element and a Point2d.
///
/// </summary>
/// <param name="elementSymbol"> The Element
/// </param>
/// <param name="point2d"> The Point
/// </param>
public Atom(System.String elementSymbol, Point2d point2d)
: this(elementSymbol)
{
this.point2d = point2d;
}
/// <summary> Translates the geometric 2DCenter of the given
/// AtomContainer container to the specified Point2d p.
///
/// </summary>
/// <param name="container"> AtomContainer which should be translated.
/// </param>
/// <param name="p"> New Location of the geometric 2D Center.
/// </param>
/// <seealso cref="get2DCenter">
/// </seealso>
/// <seealso cref="translate2DCentreOfMassTo">
/// </seealso>
public static void translate2DCenterTo(IAtomContainer container, Point2d p)
{
Point2d com = get2DCenter(container);
Vector2d translation = new Vector2d(p.x - com.x, p.y - com.y);
IAtom[] atoms = container.Atoms;
for (int i = 0; i < atoms.Length; i++)
{
if (atoms[i].getPoint2d() != null)
{
atoms[i].getPoint2d().add(translation);
}
}
}
/// <summary> Returns the geometric center of all the atoms in the atomContainer.
/// See comment for center(IAtomContainer atomCon, Dimension areaDim, HashMap renderingCoordinates) for details on coordinate sets
///
/// </summary>
/// <param name="container"> Description of the Parameter
/// </param>
/// <returns> the geometric center of the atoms in this atomContainer
/// </returns>
public static Point2d get2DCenter(IAtomContainer container)
{
double centerX = 0;
double centerY = 0;
double counter = 0;
IAtom[] atoms = container.Atoms;
for (int i = 0; i < atoms.Length; i++)
{
if (atoms[i].getPoint2d() != null)
{
centerX += atoms[i].getPoint2d().x;
centerY += atoms[i].getPoint2d().y;
counter++;
}
}
Point2d point = new Point2d(centerX / (counter), centerY / (counter));
return point;
}
//UPGRADE_NOTE: The initialization of '//logger' was moved to static method 'org.openscience.cdk.geometry.GeometryTools'. "ms-help://MS.VSCC.v80/dv_commoner/local/redirect.htm?index='!DefaultContextWindowIndex'&keyword='jlca1005'"
//private static LoggingTool //logger;
/// <summary> Adds an automatically calculated offset to the coordinates of all atoms
/// such that all coordinates are positive and the smallest x or y coordinate
/// is exactly zero, using an external set of coordinates.
/// See comment for center(IAtomContainer atomCon, Dimension areaDim, HashMap renderingCoordinates) for details on coordinate sets
///
/// </summary>
/// <param name="atomCon"> AtomContainer for which all the atoms are translated to
/// positive coordinates
/// </param>
/// <param name="renderingCoordinates"> The set of coordinates to use coming from RendererModel2D
/// </param>
//UPGRADE_TODO: Class 'java.util.HashMap' was converted to 'System.Collections.Hashtable' which has a different behavior. "ms-help://MS.VSCC.v80/dv_commoner/local/redirect.htm?index='!DefaultContextWindowIndex'&keyword='jlca1073_javautilHashMap'"
public static void translateAllPositive(IAtomContainer atomCon, System.Collections.Hashtable renderingCoordinates)
{
//UPGRADE_TODO: The equivalent in .NET for field 'java.lang.Double.MAX_VALUE' may return a different value. "ms-help://MS.VSCC.v80/dv_commoner/local/redirect.htm?index='!DefaultContextWindowIndex'&keyword='jlca1043'"
double minX = System.Double.MaxValue;
//UPGRADE_TODO: The equivalent in .NET for field 'java.lang.Double.MAX_VALUE' may return a different value. "ms-help://MS.VSCC.v80/dv_commoner/local/redirect.htm?index='!DefaultContextWindowIndex'&keyword='jlca1043'"
double minY = System.Double.MaxValue;
IAtom[] atoms = atomCon.Atoms;
for (int i = 0; i < atoms.Length; i++)
{
//UPGRADE_TODO: Method 'java.util.HashMap.get' was converted to 'System.Collections.Hashtable.Item' which has a different behavior. "ms-help://MS.VSCC.v80/dv_commoner/local/redirect.htm?index='!DefaultContextWindowIndex'&keyword='jlca1073_javautilHashMapget_javalangObject'"
if (renderingCoordinates[atoms[i]] == null && atoms[i].getPoint2d() != null)
{
renderingCoordinates[atoms[i]] = new Point2d(atoms[i].getPoint2d().x, atoms[i].getPoint2d().y);
}
//UPGRADE_TODO: Method 'java.util.HashMap.get' was converted to 'System.Collections.Hashtable.Item' which has a different behavior. "ms-help://MS.VSCC.v80/dv_commoner/local/redirect.htm?index='!DefaultContextWindowIndex'&keyword='jlca1073_javautilHashMapget_javalangObject'"
if (renderingCoordinates[atoms[i]] != null)
{
//UPGRADE_TODO: Method 'java.util.HashMap.get' was converted to 'System.Collections.Hashtable.Item' which has a different behavior. "ms-help://MS.VSCC.v80/dv_commoner/local/redirect.htm?index='!DefaultContextWindowIndex'&keyword='jlca1073_javautilHashMapget_javalangObject'"
if (((Point2d)renderingCoordinates[atoms[i]]).x < minX)
{
//UPGRADE_TODO: Method 'java.util.HashMap.get' was converted to 'System.Collections.Hashtable.Item' which has a different behavior. "ms-help://MS.VSCC.v80/dv_commoner/local/redirect.htm?index='!DefaultContextWindowIndex'&keyword='jlca1073_javautilHashMapget_javalangObject'"
minX = ((Point2d)renderingCoordinates[atoms[i]]).x;
}
//UPGRADE_TODO: Method 'java.util.HashMap.get' was converted to 'System.Collections.Hashtable.Item' which has a different behavior. "ms-help://MS.VSCC.v80/dv_commoner/local/redirect.htm?index='!DefaultContextWindowIndex'&keyword='jlca1073_javautilHashMapget_javalangObject'"
if (((Point2d)renderingCoordinates[atoms[i]]).y < minY)
{
//UPGRADE_TODO: Method 'java.util.HashMap.get' was converted to 'System.Collections.Hashtable.Item' which has a different behavior. "ms-help://MS.VSCC.v80/dv_commoner/local/redirect.htm?index='!DefaultContextWindowIndex'&keyword='jlca1073_javautilHashMapget_javalangObject'"
minY = ((Point2d)renderingCoordinates[atoms[i]]).y;
}
}
}
//logger.debug("Translating: minx=" + minX + ", minY=" + minY);
translate2D(atomCon, minX * (-1), minY * (-1), renderingCoordinates);
}
/// <summary> Rotates a molecule around a given center by a given angle
///
/// </summary>
/// <param name="atomCon"> The molecule to be rotated
/// </param>
/// <param name="center"> A point giving the rotation center
/// </param>
/// <param name="angle"> The angle by which to rotate the molecule
/// </param>
public static void rotate(IAtomContainer atomCon, Point2d center, double angle)
{
Point2d p = null;
double distance;
double offsetAngle;
IAtom atom = null;
for (int i = 0; i < atomCon.AtomCount; i++)
{
atom = atomCon.getAtomAt(i);
p = atom.getPoint2d();
offsetAngle = GeometryTools.getAngle(p.x - center.x, p.y - center.y);
distance = p.distance(center);
p.x = center.x + (System.Math.Sin(angle + offsetAngle) * distance);
p.y = center.y - (System.Math.Cos(angle + offsetAngle) * distance);
}
}
/// <summary> Determines the scale factor for displaying a structure loaded from disk in
/// a frame, using an external set of coordinates. An average of all bond length values is produced and a scale
/// factor is determined which would scale the given molecule such that its
/// See comment for center(IAtomContainer atomCon, Dimension areaDim, HashMap renderingCoordinates) for details on coordinate sets
///
/// </summary>
/// <param name="ac"> The AtomContainer for which the ScaleFactor is to be
/// calculated
/// </param>
/// <param name="bondLength"> The target bond length
/// </param>
/// <param name="renderingCoordinates"> The set of coordinates to use coming from RendererModel2D
/// </param>
/// <returns> The ScaleFactor with which the AtomContainer must be
/// scaled to have the target bond length
/// </returns>
//UPGRADE_TODO: Class 'java.util.HashMap' was converted to 'System.Collections.Hashtable' which has a different behavior. "ms-help://MS.VSCC.v80/dv_commoner/local/redirect.htm?index='!DefaultContextWindowIndex'&keyword='jlca1073_javautilHashMap'"
public static double getScaleFactor(IAtomContainer ac, double bondLength, System.Collections.Hashtable renderingCoordinates)
{
IAtom[] atoms = ac.Atoms;
for (int i = 0; i < atoms.Length; i++)
{
//UPGRADE_TODO: Method 'java.util.HashMap.get' was converted to 'System.Collections.Hashtable.Item' which has a different behavior. "ms-help://MS.VSCC.v80/dv_commoner/local/redirect.htm?index='!DefaultContextWindowIndex'&keyword='jlca1073_javautilHashMapget_javalangObject'"
if (renderingCoordinates[atoms[i]] == null && atoms[i].getPoint2d() != null)
{
renderingCoordinates[atoms[i]] = new Point2d(atoms[i].getPoint2d().x, atoms[i].getPoint2d().y);
}
}
double currentAverageBondLength = getBondLengthAverage(ac, renderingCoordinates);
if (currentAverageBondLength == 0 || System.Double.IsNaN(currentAverageBondLength))
return 1;
return bondLength / currentAverageBondLength;
}
/// <summary> Constructs and initializes a Point2f from the specified Point2d.</summary>
/// <param name="p1">the Point2d containing the initialization x y data
/// </param>
public Point2f(Point2d p1) : base(p1)
{
}
/// <summary> Computes the L-infinite distance between this point and point p1.
/// The L-infinite distance is equal to MAX[abs(x1-x2), abs(y1-y2)].
/// </summary>
/// <param name="p1">the other point
/// </param>
public double distanceLinf(Point2d p1)
{
return(System.Math.Max(System.Math.Abs(x - p1.x), System.Math.Abs(y - p1.y)));
}
/// <summary> Computes the L-1 (Manhattan) distance between this point and point p1.
/// The L-1 distance is equal to abs(x1-x2) + abs(y1-y2).
/// </summary>
/// <param name="p1">the other point
/// </param>
public double distanceL1(Point2d p1)
{
return(System.Math.Abs(x - p1.x) + System.Math.Abs(y - p1.y));
}
/// <summary> Computes the distance between this point and point p1.</summary>
/// <param name="p1">the other point
/// </param>
public double distance(Point2d p1)
{
return(System.Math.Sqrt(distanceSquared(p1)));
}
/// <summary>
/// Sets a point specifying the location of this
/// atom in a 2D space.
///
/// </summary>
/// <param name="point2d"> A point in a 2D plane
///
/// </param>
/// <seealso cref="getPoint2d">
/// </seealso>
public virtual void setPoint2d(javax.vecmath.Point2d point2d)
{
this.point2d = point2d;
notifyChanged();
}
/// <summary> Constructs an Atom from an Element and a Point2d.
///
/// </summary>
/// <param name="elementSymbol"> The Element
/// </param>
/// <param name="point2d"> The Point
/// </param>
public Atom(System.String elementSymbol, Point2d point2d)
: this(elementSymbol)
{
this.point2d = point2d;
}
/// <summary> Returns the atom of the given molecule that is closest to the given
/// coordinates, using an external set of coordinates.
/// See comment for center(IAtomContainer atomCon, Dimension areaDim, HashMap renderingCoordinates) for details on coordinate sets
///
/// </summary>
/// <param name="xPosition"> The x coordinate
/// </param>
/// <param name="yPosition"> The y coordinate
/// </param>
/// <param name="renderingCoordinates"> The set of coordinates to use coming from RendererModel2D
/// </param>
/// <returns> The atom that is closest to the given coordinates
/// </returns>
//UPGRADE_TODO: Class 'java.util.HashMap' was converted to 'System.Collections.Hashtable' which has a different behavior. "ms-help://MS.VSCC.v80/dv_commoner/local/redirect.htm?index='!DefaultContextWindowIndex'&keyword='jlca1073_javautilHashMap'"
public static IAtom getClosestAtom(int xPosition, int yPosition, IChemModel model, IAtom ignore, System.Collections.Hashtable renderingCoordinates)
{
IAtom closestAtom = null;
IAtom currentAtom;
double smallestMouseDistance = -1;
double mouseDistance;
double atomX;
double atomY;
IAtomContainer all = ChemModelManipulator.getAllInOneContainer(model);
for (int i = 0; i < all.AtomCount; i++)
{
currentAtom = all.getAtomAt(i);
//UPGRADE_TODO: Method 'java.util.HashMap.get' was converted to 'System.Collections.Hashtable.Item' which has a different behavior. "ms-help://MS.VSCC.v80/dv_commoner/local/redirect.htm?index='!DefaultContextWindowIndex'&keyword='jlca1073_javautilHashMapget_javalangObject'"
if (renderingCoordinates[currentAtom] == null && currentAtom.getPoint2d() != null)
{
renderingCoordinates[currentAtom] = new Point2d(currentAtom.getPoint2d().x, currentAtom.getPoint2d().y);
}
//UPGRADE_TODO: Method 'java.util.HashMap.get' was converted to 'System.Collections.Hashtable.Item' which has a different behavior. "ms-help://MS.VSCC.v80/dv_commoner/local/redirect.htm?index='!DefaultContextWindowIndex'&keyword='jlca1073_javautilHashMapget_javalangObject'"
if (currentAtom != ignore && renderingCoordinates[currentAtom] != null)
{
//UPGRADE_TODO: Method 'java.util.HashMap.get' was converted to 'System.Collections.Hashtable.Item' which has a different behavior. "ms-help://MS.VSCC.v80/dv_commoner/local/redirect.htm?index='!DefaultContextWindowIndex'&keyword='jlca1073_javautilHashMapget_javalangObject'"
atomX = ((Point2d)renderingCoordinates[currentAtom]).x;
//UPGRADE_TODO: Method 'java.util.HashMap.get' was converted to 'System.Collections.Hashtable.Item' which has a different behavior. "ms-help://MS.VSCC.v80/dv_commoner/local/redirect.htm?index='!DefaultContextWindowIndex'&keyword='jlca1073_javautilHashMapget_javalangObject'"
atomY = ((Point2d)renderingCoordinates[currentAtom]).y;
mouseDistance = System.Math.Sqrt(System.Math.Pow(atomX - xPosition, 2) + System.Math.Pow(atomY - yPosition, 2));
if (mouseDistance < smallestMouseDistance || smallestMouseDistance == -1)
{
smallestMouseDistance = mouseDistance;
closestAtom = currentAtom;
}
}
}
return closestAtom;
}
/// <summary> Sorts a Vector of atoms such that the 2D distances of the atom locations
/// from a given point are smallest for the first atoms in the vector
/// See comment for center(IAtomContainer atomCon, Dimension areaDim, HashMap renderingCoordinates) for details on coordinate sets
///
/// </summary>
/// <param name="point"> The point from which the distances to the atoms are measured
/// </param>
/// <param name="atoms"> The atoms for which the distances to point are measured
/// </param>
public static void sortBy2DDistance(IAtom[] atoms, Point2d point)
{
double distance1;
double distance2;
IAtom atom1 = null;
IAtom atom2 = null;
bool doneSomething = false;
do
{
doneSomething = false;
for (int f = 0; f < atoms.Length - 1; f++)
{
atom1 = atoms[f];
atom2 = atoms[f + 1];
distance1 = point.distance(atom1.getPoint2d());
distance2 = point.distance(atom2.getPoint2d());
if (distance2 < distance1)
{
atoms[f] = atom2;
atoms[f + 1] = atom1;
doneSomething = true;
}
}
}
while (doneSomething);
}
/// <summary> Computes the square of the distance between this point and point p1.</summary>
/// <param name="p1">the other point
/// </param>
public double distanceSquared(Point2d p1)
{
double dx = x - p1.x;
double dy = y - p1.y;
return dx * dx + dy * dy;
}
/// <summary> Determines the normalized vector orthogonal on the vector p1->p2.
///
/// </summary>
/// <param name="p1"> Description of the Parameter
/// </param>
/// <param name="p2"> Description of the Parameter
/// </param>
/// <returns> Description of the Return Value
/// </returns>
public static Vector2d calculatePerpendicularUnitVector(Point2d p1, Point2d p2)
{
Vector2d v = new Vector2d();
v.sub(p2, p1);
v.normalize();
// Return the perpendicular vector
return new Vector2d((-1.0) * v.y, v.x);
}
/// <summary> Computes the distance between this point and point p1.</summary>
/// <param name="p1">the other point
/// </param>
public double distance(Point2d p1)
{
return System.Math.Sqrt(distanceSquared(p1));
}
/// <summary> Translates a molecule from the origin to a new point denoted by a vector, using an external set of coordinates.
/// See comment for center(IAtomContainer atomCon, Dimension areaDim, HashMap renderingCoordinates) for details on coordinate sets
///
/// </summary>
/// <param name="atomCon"> molecule to be translated
/// </param>
/// <param name="vector"> dimension that represents the translation vector
/// </param>
/// <param name="renderingCoordinates"> The set of coordinates to use coming from RendererModel2D
/// </param>
//UPGRADE_TODO: Class 'java.util.HashMap' was converted to 'System.Collections.Hashtable' which has a different behavior. "ms-help://MS.VSCC.v80/dv_commoner/local/redirect.htm?index='!DefaultContextWindowIndex'&keyword='jlca1073_javautilHashMap'"
public static void translate2D(IAtomContainer atomCon, Vector2d vector, System.Collections.Hashtable renderingCoordinates)
{
IAtom[] atoms = atomCon.Atoms;
for (int i = 0; i < atoms.Length; i++)
{
//UPGRADE_TODO: Method 'java.util.HashMap.get' was converted to 'System.Collections.Hashtable.Item' which has a different behavior. "ms-help://MS.VSCC.v80/dv_commoner/local/redirect.htm?index='!DefaultContextWindowIndex'&keyword='jlca1073_javautilHashMapget_javalangObject'"
if (renderingCoordinates[atoms[i]] == null && atoms[i].getPoint2d() != null)
{
renderingCoordinates[atoms[i]] = new Point2d(atoms[i].getPoint2d().x, atoms[i].getPoint2d().y);
}
//UPGRADE_TODO: Method 'java.util.HashMap.get' was converted to 'System.Collections.Hashtable.Item' which has a different behavior. "ms-help://MS.VSCC.v80/dv_commoner/local/redirect.htm?index='!DefaultContextWindowIndex'&keyword='jlca1073_javautilHashMapget_javalangObject'"
if (((Point2d)renderingCoordinates[atoms[i]]) != null)
{
//UPGRADE_TODO: Method 'java.util.HashMap.get' was converted to 'System.Collections.Hashtable.Item' which has a different behavior. "ms-help://MS.VSCC.v80/dv_commoner/local/redirect.htm?index='!DefaultContextWindowIndex'&keyword='jlca1073_javautilHashMapget_javalangObject'"
((Point2d)renderingCoordinates[atoms[i]]).add(vector);
}
else
{
//logger.warn("Could not translate atom in 2D space");
}
}
}
/// <summary> Computes the L-1 (Manhattan) distance between this point and point p1.
/// The L-1 distance is equal to abs(x1-x2) + abs(y1-y2).
/// </summary>
/// <param name="p1">the other point
/// </param>
public double distanceL1(Point2d p1)
{
return System.Math.Abs(x - p1.x) + System.Math.Abs(y - p1.y);
}
/// <summary> Returns the geometric center of all the rings in this ringset.
/// See comment for center(IAtomContainer atomCon, Dimension areaDim, HashMap renderingCoordinates) for details on coordinate sets
///
/// </summary>
/// <param name="ringSet"> Description of the Parameter
/// </param>
/// <returns> the geometric center of the rings in this ringset
/// </returns>
public static Point2d get2DCenter(IRingSet ringSet)
{
double centerX = 0;
double centerY = 0;
for (int i = 0; i < ringSet.AtomContainerCount; i++)
{
Point2d centerPoint = GeometryTools.get2DCenter((IRing)ringSet.getAtomContainer(i));
centerX += centerPoint.x;
centerY += centerPoint.y;
}
Point2d point = new Point2d(centerX / ((double)ringSet.AtomContainerCount), centerY / ((double)ringSet.AtomContainerCount));
return point;
}
/// <summary> Computes the L-infinite distance between this point and point p1.
/// The L-infinite distance is equal to MAX[abs(x1-x2), abs(y1-y2)].
/// </summary>
/// <param name="p1">the other point
/// </param>
public double distanceLinf(Point2d p1)
{
return System.Math.Max(System.Math.Abs(x - p1.x), System.Math.Abs(y - p1.y));
}
/// <summary> Returns the geometric center of all the atoms in the atomContainer.
/// See comment for center(IAtomContainer atomCon, Dimension areaDim, HashMap renderingCoordinates) for details on coordinate sets
///
/// </summary>
/// <param name="container"> Description of the Parameter
/// </param>
/// <param name="renderingCoordinates"> The set of coordinates to use coming from RendererModel2D
/// </param>
/// <returns> the geometric center of the atoms in this atomContainer
/// </returns>
//UPGRADE_TODO: Class 'java.util.HashMap' was converted to 'System.Collections.Hashtable' which has a different behavior. "ms-help://MS.VSCC.v80/dv_commoner/local/redirect.htm?index='!DefaultContextWindowIndex'&keyword='jlca1073_javautilHashMap'"
public static Point2d get2DCenter(IAtomContainer container, System.Collections.Hashtable renderingCoordinates)
{
double centerX = 0;
double centerY = 0;
double counter = 0;
IAtom[] atoms = container.Atoms;
for (int i = 0; i < atoms.Length; i++)
{
if (atoms[i].getPoint2d() != null)
{
//UPGRADE_TODO: Method 'java.util.HashMap.get' was converted to 'System.Collections.Hashtable.Item' which has a different behavior. "ms-help://MS.VSCC.v80/dv_commoner/local/redirect.htm?index='!DefaultContextWindowIndex'&keyword='jlca1073_javautilHashMapget_javalangObject'"
centerX += ((Point2d)renderingCoordinates[atoms[i]]).x;
//UPGRADE_TODO: Method 'java.util.HashMap.get' was converted to 'System.Collections.Hashtable.Item' which has a different behavior. "ms-help://MS.VSCC.v80/dv_commoner/local/redirect.htm?index='!DefaultContextWindowIndex'&keyword='jlca1073_javautilHashMapget_javalangObject'"
centerY += ((Point2d)renderingCoordinates[atoms[i]]).y;
counter++;
}
}
Point2d point = new Point2d(centerX / (counter), centerY / (counter));
return point;
}
/// <summary> Constructs and initializes a Point2d from the specified Point2d.</summary>
/// <param name="p1">the Point2d containing the initialization x y data
/// </param>
public Point2d(Point2d p1):base(p1)
{
}
public virtual IPseudoAtom newPseudoAtom(String label, Point2d point2d)
{
return new PseudoAtom(label, point2d);
}
public virtual IAtom newAtom(String elementSymbol, Point2d point2d)
{
return new Atom(elementSymbol, point2d);
}
/// <summary>
/// Sets a point specifying the location of this
/// atom in a 2D space.
///
/// </summary>
/// <param name="point2d"> A point in a 2D plane
///
/// </param>
/// <seealso cref="getPoint2d">
/// </seealso>
public virtual void setPoint2d(javax.vecmath.Point2d point2d)
{
this.point2d = point2d;
notifyChanged();
}
public static double giveAngleBothMethods(Point2d from, Point2d to1, Point2d to2, bool bool_Renamed)
{
double[] A = new double[2];
from.get_Renamed(A);
double[] B = new double[2];
to1.get_Renamed(B);
double[] C = new double[2];
to2.get_Renamed(C);
double angle1 = System.Math.Atan2((B[1] - A[1]), (B[0] - A[0]));
double angle2 = System.Math.Atan2((C[1] - A[1]), (C[0] - A[0]));
double angle = angle2 - angle1;
if (angle2 < 0 && angle1 > 0 && angle2 < -(System.Math.PI / 2))
{
angle = System.Math.PI + angle2 + System.Math.PI - angle1;
}
if (angle2 > 0 && angle1 < 0 && angle1 < -(System.Math.PI / 2))
{
angle = -System.Math.PI + angle2 - System.Math.PI - angle1;
}
if (bool_Renamed && angle < 0)
{
return (2 * System.Math.PI + angle);
}
else
{
return (angle);
}
}
