コード例 #1
0
        private static Globals.BondStereo BondStereoFromMolfile(int molfileBondStereo)
        {
            //Translates from a molfile convention bond stereochemistry number to the enumeration used in the model
            //The opposite of BondStereoFromModel
            Globals.BondStereo modelStereo = 0;

            //MOLFILE: 0 is NOT stereo, 1 is UP,    6 is DOWN,  4 is EITHER
            //MODEL  : 0 is None,       1 is Wedge, 2 is Hatch, 3 is Indeterminate
            switch (molfileBondStereo)
            {
            case 0:
                modelStereo = Globals.BondStereo.None;
                break;

            case 1:
                modelStereo = Globals.BondStereo.Wedge;
                break;

            case 4:
                modelStereo = Globals.BondStereo.Indeterminate;
                break;

            case 6:
                modelStereo = Globals.BondStereo.Hatch;
                break;

            default:
                modelStereo = Globals.BondStereo.None;
                break;
            }
            return(modelStereo);
        }
コード例 #2
0
        private static int BondStereoFromModel(Globals.BondStereo modelBondStereo)
        {
            //Translates from the model enumerated bond stereochemistry to the molfile convention
            //The opposite of BondStereoFromMolfile
            int molfileStereo = 0;

            //MODEL  : 0 is None,       1 is Wedge, 2 is Hatch, 3 is Indeterminate
            //MOLFILE: 0 is NOT stereo, 1 is UP,    6 is DOWN,  4 is EITHER
            switch (modelBondStereo)
            {
            case Globals.BondStereo.None:
                molfileStereo = 0;
                break;

            case Globals.BondStereo.Wedge:
                molfileStereo = 1;
                break;

            case Globals.BondStereo.Hatch:
                molfileStereo = 6;
                break;

            case Globals.BondStereo.Indeterminate:
                molfileStereo = 4;
                break;

            default:
                molfileStereo = 4;
                break;
            }
            return(molfileStereo);
        }
コード例 #3
0
        private static int MdlBondStereo(Globals.BondStereo code)
        {
            int stereo;

            switch (code)
            {
            case Globals.BondStereo.None:
                stereo = 0;
                break;

            case Globals.BondStereo.Wedge:
                stereo = 1;
                break;

            case Globals.BondStereo.Hatch:
                stereo = 6;
                break;

            case Globals.BondStereo.Indeterminate:
                stereo = 4;
                break;

            default:
                stereo = 0;
                break;
            }
            return(stereo);
        }
コード例 #4
0
        private static int MdlBondStereo(Globals.BondStereo code)
        {
            int stereo = 0;

            if (code == Globals.BondStereo.None)
            {
                stereo = 0;
            }
            else if (code == Globals.BondStereo.Wedge)
            {
                stereo = 1;
            }
            else if (code == Globals.BondStereo.Hatch)
            {
                stereo = 6;
            }
            else
            {
                stereo = 0;
            }
            return(stereo);
        }
コード例 #5
0
        public static BondLayout GetBondDescriptor(AtomVisual startAtomVisual, AtomVisual endAtomVisual,
                                                   double modelXamlBondLength, Globals.BondStereo parentStereo,
                                                   Point startAtomPosition, Point endAtomPosition,
                                                   double?parentOrderValue, Globals.BondDirection parentPlacement,
                                                   Point?centroid, Point?secondaryCentroid)
        {
            if (parentStereo == Globals.BondStereo.Wedge || parentStereo == Globals.BondStereo.Hatch)
            {
                WedgeBondLayout wbd = new WedgeBondLayout()
                {
                    Start           = startAtomPosition,
                    End             = endAtomPosition,
                    StartAtomVisual = startAtomVisual,
                    EndAtomVisual   = endAtomVisual
                };

                var  endAtom    = endAtomVisual.ParentAtom;
                var  otherBonds = endAtom.Bonds.Except(new[] { startAtomVisual.ParentAtom.BondBetween(endAtom) }).ToList();
                Bond bond       = null;
                if (otherBonds.Any())
                {
                    bond = otherBonds.ToArray()[0];
                }

                bool chamferBond = (otherBonds.Any() &&
                                    (endAtom.Element as Element) == Globals.PeriodicTable.C &&
                                    endAtom.SymbolText == "" &&
                                    bond.Order == Globals.OrderSingle);
                if (!chamferBond)
                {
                    wbd.CappedOff = false;
                    BondGeometry.GetWedgeBondGeometry(wbd, modelXamlBondLength);
                }
                else
                {
                    var nonHPs = (from b in otherBonds
                                  select b.OtherAtom(endAtom).Position).ToList();
                    if (nonHPs.Any())
                    {
                        wbd.CappedOff = true;
                        BondGeometry.GetChamferedWedgeGeometry(wbd, modelXamlBondLength, nonHPs);
                    }
                    else
                    {
                        wbd.CappedOff = false;
                        BondGeometry.GetWedgeBondGeometry(wbd, modelXamlBondLength);
                    }
                }

                return(wbd);
            }

            //wavy bond
            if (parentStereo == Globals.BondStereo.Indeterminate && parentOrderValue == 1.0)
            {
                BondLayout sbd = new BondLayout
                {
                    Start           = startAtomPosition,
                    End             = endAtomPosition,
                    StartAtomVisual = startAtomVisual,
                    EndAtomVisual   = endAtomVisual
                };
                BondGeometry.GetWavyBondGeometry(sbd, modelXamlBondLength);
                return(sbd);
            }

            switch (parentOrderValue)
            {
            //indeterminate double
            case 2 when parentStereo == Globals.BondStereo.Indeterminate:
                DoubleBondLayout dbd = new DoubleBondLayout()
                {
                    StartAtomVisual = startAtomVisual,
                    EndAtomVisual   = endAtomVisual,
                    Start           = startAtomPosition,
                    End             = endAtomPosition
                };
                BondGeometry.GetCrossedDoubleGeometry(dbd, modelXamlBondLength);
                return(dbd);

            //partial or undefined bonds
            case 0:
            case 0.5:
            case 1.0:
                BondLayout sbd = new BondLayout
                {
                    Start           = startAtomPosition,
                    End             = endAtomPosition,
                    StartAtomVisual = startAtomVisual,
                    EndAtomVisual   = endAtomVisual
                };

                BondGeometry.GetSingleBondGeometry(sbd);
                return(sbd);

            //double bond & 1.5 bond
            case 1.5:
            case 2:
                DoubleBondLayout dbd2 = new DoubleBondLayout()
                {
                    StartAtomVisual   = startAtomVisual,
                    EndAtomVisual     = endAtomVisual,
                    Start             = startAtomPosition,
                    End               = endAtomPosition,
                    Placement         = parentPlacement,
                    PrimaryCentroid   = centroid,
                    SecondaryCentroid = secondaryCentroid
                };

                BondGeometry.GetDoubleBondGeometry(dbd2, modelXamlBondLength);
                return(dbd2);

            //triple and 2.5 bond
            case 2.5:
            case 3:
                TripleBondLayout tbd = new TripleBondLayout()
                {
                    StartAtomVisual   = startAtomVisual,
                    EndAtomVisual     = endAtomVisual,
                    Start             = startAtomPosition,
                    End               = endAtomPosition,
                    Placement         = parentPlacement,
                    PrimaryCentroid   = centroid,
                    SecondaryCentroid = secondaryCentroid
                };
                BondGeometry.GetTripleBondGeometry(tbd, modelXamlBondLength);
                return(tbd);

            default:
                return(null);
            }
        }
コード例 #6
0
        public static BondLayout GetBondDescriptor(AtomVisual startAtomVisual, AtomVisual endAtomVisual,
                                                   double modelXamlBondLength, Globals.BondStereo parentStereo,
                                                   Point startAtomPosition, Point endAtomPosition,
                                                   double?parentOrderValue, Globals.BondDirection parentPlacement,
                                                   Point?centroid, Point?secondaryCentroid, double standoff)
        {
            List <Point> startAtomHull = new List <Point>();
            List <Point> endAtomHull   = new List <Point>();

            if (startAtomVisual.ParentAtom.SymbolText != "" || startAtomVisual.ShowAllCarbons)
            {
                startAtomHull = startAtomVisual.Hull;
            }
            if (endAtomVisual.ParentAtom.SymbolText != "" || endAtomVisual.ShowAllCarbons)
            {
                endAtomHull = endAtomVisual.Hull;
            }
            if ((parentStereo == Globals.BondStereo.Wedge || parentStereo == Globals.BondStereo.Hatch) &&
                parentOrderValue == 1)
            {
                WedgeBondLayout wbd = new WedgeBondLayout
                {
                    Start         = startAtomPosition,
                    End           = endAtomPosition,
                    StartAtomHull = startAtomHull,
                    EndAtomHull   = endAtomHull
                };

                var endAtom    = endAtomVisual.ParentAtom;
                var otherBonds = endAtom.Bonds.Except(new[] { startAtomVisual.ParentAtom.BondBetween(endAtom) }).ToList();

                Bond bond    = null;
                bool oblique = true;
                if (otherBonds.Any())
                {
                    bond = otherBonds.ToArray()[0];
                    Vector wedgevector = wbd.End - wbd.Start;
                    foreach (Bond b in otherBonds)
                    {
                        Atom   otherAtom = b.OtherAtom(endAtom);
                        Vector v         = wbd.End - otherAtom.Position;
                        double angle     = System.Math.Abs(Vector.AngleBetween(wedgevector, v));

                        if (angle < 109.5 || angle > 130.5)
                        {
                            oblique = false;
                            break;
                        }
                    }
                }

                bool chamferBond = otherBonds.Any() &&
                                   oblique &&
                                   (endAtom.Element as Element) == Globals.PeriodicTable.C &&
                                   endAtom.SymbolText == "" &&
                                   bond.Order == Globals.OrderSingle;
                if (!chamferBond)
                {
                    wbd.CappedOff = false;
                    BondGeometry.GetWedgeBondGeometry(wbd, modelXamlBondLength, standoff);
                }
                else
                {
                    var nonHPs = (from b in otherBonds
                                  select b.OtherAtom(endAtom).Position).ToList();
                    if (nonHPs.Any())
                    {
                        wbd.CappedOff = true;
                        BondGeometry.GetChamferedWedgeGeometry(wbd, modelXamlBondLength, nonHPs, standoff);
                    }
                    else
                    {
                        wbd.CappedOff = false;
                        BondGeometry.GetWedgeBondGeometry(wbd, modelXamlBondLength, standoff);
                    }
                }

                return(wbd);
            }

            //wavy bond
            if (parentStereo == Globals.BondStereo.Indeterminate && parentOrderValue == 1.0)
            {
                BondLayout sbd = new BondLayout
                {
                    Start         = startAtomPosition,
                    End           = endAtomPosition,
                    StartAtomHull = startAtomHull,
                    EndAtomHull   = endAtomHull
                };
                BondGeometry.GetWavyBondGeometry(sbd, modelXamlBondLength, standoff);
                return(sbd);
            }

            switch (parentOrderValue)
            {
            //indeterminate double
            case 2 when parentStereo == Globals.BondStereo.Indeterminate:
                DoubleBondLayout dbd = new DoubleBondLayout()
                {
                    StartAtomHull          = startAtomHull,
                    EndAtomHull            = endAtomHull,
                    Start                  = startAtomPosition,
                    End                    = endAtomPosition,
                    StartNeigbourPositions = (from Atom a in startAtomVisual.ParentAtom.NeighboursExcept(endAtomVisual.ParentAtom)
                                              select a.Position).ToList(),
                    EndNeighbourPositions = (from Atom a in endAtomVisual.ParentAtom.NeighboursExcept(startAtomVisual.ParentAtom)
                                             select a.Position).ToList()
                };
                BondGeometry.GetCrossedDoubleGeometry(dbd, modelXamlBondLength, standoff);
                return(dbd);

            //partial or undefined bonds
            case 0:
            case 0.5:
            case 1.0:
                BondLayout sbd = new BondLayout
                {
                    Start         = startAtomPosition,
                    End           = endAtomPosition,
                    StartAtomHull = startAtomHull,
                    EndAtomHull   = endAtomHull
                };

                BondGeometry.GetSingleBondGeometry(sbd, standoff);
                return(sbd);

            //double bond & 1.5 bond
            case 1.5:
            case 2:
                DoubleBondLayout dbd2 = new DoubleBondLayout()
                {
                    StartAtomHull          = startAtomHull,
                    EndAtomHull            = endAtomHull,
                    Start                  = startAtomPosition,
                    End                    = endAtomPosition,
                    Placement              = parentPlacement,
                    PrimaryCentroid        = centroid,
                    SecondaryCentroid      = secondaryCentroid,
                    StartNeigbourPositions = (from Atom a in startAtomVisual.ParentAtom.NeighboursExcept(endAtomVisual.ParentAtom)
                                              select a.Position).ToList(),
                    EndNeighbourPositions = (from Atom a in endAtomVisual.ParentAtom.NeighboursExcept(startAtomVisual.ParentAtom)
                                             select a.Position).ToList()
                };

                BondGeometry.GetDoubleBondGeometry(dbd2, modelXamlBondLength, standoff);
                return(dbd2);

            //triple and 2.5 bond
            case 2.5:
            case 3:
                TripleBondLayout tbd = new TripleBondLayout()
                {
                    StartAtomHull     = startAtomHull,
                    EndAtomHull       = endAtomHull,
                    Start             = startAtomPosition,
                    End               = endAtomPosition,
                    Placement         = parentPlacement,
                    PrimaryCentroid   = centroid,
                    SecondaryCentroid = secondaryCentroid
                };
                BondGeometry.GetTripleBondGeometry(tbd, modelXamlBondLength, standoff);
                return(tbd);

            default:
                return(null);
            }
        }
コード例 #7
0
        public BondLayout GetBondLayout(Point startPoint, Point endPoint, double bondLength,
                                        Globals.BondStereo stereo, string order, Ring existingRing = null,
                                        Ring subsidiaryRing = null)
        {
            BondLayout descriptor = null;

            //check to see if it's a wedge or a hatch yet
            if (stereo == Globals.BondStereo.Wedge || stereo == Globals.BondStereo.Hatch)
            {
                var wbd = new WedgeBondLayout {
                    Start = startPoint, End = endPoint
                };
                BondGeometry.GetWedgeBondGeometry(wbd, bondLength, CurrentEditor.ViewModel.Standoff);
                return(wbd);
            }

            if (stereo == Globals.BondStereo.Indeterminate && (order == Globals.OrderSingle))
            {
                descriptor = new BondLayout {
                    Start = startPoint, End = endPoint
                };
                BondGeometry.GetWavyBondGeometry(descriptor, bondLength, CurrentEditor.ViewModel.Standoff);
                return(descriptor);
            }

            var ordervalue = Bond.OrderToOrderValue(order);

            //single or dotted bond
            if (ordervalue <= 1)
            {
                descriptor = new BondLayout {
                    Start = startPoint, End = endPoint
                };
                BondGeometry.GetSingleBondGeometry(descriptor, CurrentEditor.ViewModel.Standoff);
            }

            //double bond
            if (ordervalue == 2 || ordervalue == 1.5)
            {
                DoubleBondLayout dbd = new DoubleBondLayout {
                    Start = startPoint, End = endPoint
                };
                if (stereo == Globals.BondStereo.Indeterminate)
                {
                    BondGeometry.GetCrossedDoubleGeometry(dbd, bondLength, CurrentEditor.ViewModel.Standoff);
                }
                else
                {
                    dbd.PrimaryCentroid   = existingRing?.Centroid;
                    dbd.SecondaryCentroid = subsidiaryRing?.Centroid;
                    BondGeometry.GetDoubleBondGeometry(dbd, bondLength, CurrentEditor.ViewModel.Standoff);
                }

                descriptor = dbd;
            }

            //tripe bond
            if (ordervalue == 2.5 || ordervalue == 3)
            {
                var tbd = new TripleBondLayout {
                    Start = startPoint, End = endPoint
                };
                BondGeometry.GetTripleBondGeometry(tbd, bondLength, CurrentEditor.ViewModel.Standoff);
                descriptor = tbd;
            }

            return(descriptor);
        }