/// <summary>
/// Get molecule string in correct format
/// </summary>
/// <param name="vo"></param>
/// <param name="structureExportFormat"></param>
/// <returns></returns>
string GetMoleculeString(
object vo,
ExportStructureFormat structureExportFormat)
{
string molString = "";
MoleculeMx cs = (MoleculeMx)vo;
if (structureExportFormat == ExportStructureFormat.Chime)
{
molString = cs.GetChimeString(); // save structure as Chime
}
else if (structureExportFormat == ExportStructureFormat.Smiles)
{
molString = cs.GetSmilesString(); // save structure as Smiles
}
else if (structureExportFormat == ExportStructureFormat.Molfile)
{
molString = cs.GetMolfileString(); // save structure as molfile
}
else // save structure as molfile as default
{
molString = cs.GetMolfileString();
}
return(molString);
}
/// <summary>
/// Perform a full structure search of query molecule against target molecule
/// </summary>
/// <param name="query"></param>
/// <param name="target"></param>
/// <returns></returns>
public bool IsFSSMatch(
MoleculeMx query,
MoleculeMx target)
{
if (query.IsBiopolymerFormat || target.IsBiopolymerFormat)
{
if (!query.IsBiopolymerFormat || !target.IsBiopolymerFormat)
{
return(false);
}
if (Lex.Eq(query.PrimaryValue, target.PrimaryValue))
{
return(true);
}
else
{
return(false);
}
}
SetFSSQueryMolecule(query);
bool b = IsFSSMatch(target);
return(b);
}
/// <summary>
/// Convert this molecule to a new type
/// </summary>
/// <param name="newType"></param>
public void ConvertToNewType(
MoleculeFormat newType)
{
if (PrimaryFormat == newType)
{
return; // no change in type
}
else if (PrimaryFormat == MoleculeFormat.Molfile && newType == MoleculeFormat.Chime)
{
if (!Lex.IsNullOrEmpty(MolfileString))
{
ChimeString = MolfileStringToChimeString(MolfileString);
}
PrimaryFormat = MoleculeFormat.Chime;
}
else if (PrimaryFormat == MoleculeFormat.Chime && newType == MoleculeFormat.Molfile)
{
if (!Lex.IsNullOrEmpty(ChimeString))
{
MolfileString = ChimeStringToMolfileString(ChimeString);
}
PrimaryFormat = MoleculeFormat.Molfile;
}
else
{
MoleculeMx cs2 = ConvertTo(newType);
cs2.MemberwiseCopy(this);
}
return;
}
/// <summary>
/// Convert from one format to another
/// </summary>
/// <param name="newFormat"></param>
/// <returns></returns>
public MoleculeMx ConvertTo(
MoleculeFormat molFormatType)
{
string molString, msg;
bool conversionFailed = false;
MoleculeMx mol = new MoleculeMx(molFormatType);
try
{
// If no change in type, just copy value
if (this.PrimaryFormat == molFormatType) // any change in type?
{
molString = this.PrimaryValue;
}
else
{
molString = GetMoleculeString(molFormatType); // convert from old type if possible
}
mol.SetPrimaryTypeAndValue(molFormatType, molString);
return(mol);
}
catch (Exception ex) // handle structures that don't convert - issue #216
{
//DebugLog.Message("ChemicalStructure.Convert exception for structure: \r\n" + Value + "\r\n" +
// DebugLog.FormatExceptionMessage(ex));
//throw new Exception(ex.Message, ex);
return(new MoleculeMx(PrimaryFormat, "")); // return blank structure
}
}
/// <summary>
/// Compare two molecules for full equality
/// </summary>
/// <param name="query"></param>
/// <param name="target"></param>
/// <returns></returns>
public bool Equal(
MoleculeMx query,
MoleculeMx target)
{
string switches = "All";
return(FullStructureMatch(query, target, switches));
}
/// <summary>
/// Set substructure search query molecule
/// </summary>
/// <param name="cs"></param>
public void SetSSSQueryMolecule(
MoleculeMx cs)
{
QueryMol = cs.Clone();
SSSQueryMol = CdkMolFactory.NewCdkMol(cs);
CdkMolUtil.SetSSSQueryMolecule(SSSQueryMol);
return;
}
/// <summary>
/// Do a SSS using the predefined query molecule and supplied target molecule
/// </summary>
/// <returns></returns>
public bool IsSSSMatch(MoleculeMx cs)
{
if (QueryMol == null || cs.IsBiopolymerFormat) // fix later
{
return(false);
}
TargetMol = cs;
SSSTargetMol = CdkMolFactory.NewCdkMol(cs);
bool b = CdkMolUtil.IsSSSMatch(SSSTargetMol);
return(b);
}
public static string HelmToSvg(
MoleculeMx mol)
{
string svg = mol.SvgString;
if (mol.PrimaryFormat == MoleculeFormat.Helm && Lex.IsDefined(mol.SvgString))
{
return(svg);
}
string helm = mol.HelmString;
svg = HelmControl.GetSvg(helm);
return(svg);
}
/// <summary>
/// Set full structure search query molecule
/// </summary>
/// <param name="cs"></param>
public void SetFSSQueryMolecule(
MoleculeMx cs)
{
if (cs.IsBiopolymerFormat) // fix later
{
QueryMol = cs;
return;
}
QueryMol = cs.Clone();
FSSQueryMol = CdkMolFactory.NewCdkMol(cs);
CdkMolUtil.SetFSSQueryMolecule(FSSQueryMol);
return;
}
/// <summary>
/// Perform a substructure search
/// </summary>
/// <param name="query"></param>
/// <param name="target"></param>
/// <returns></returns>
public bool IsSSSMatch(
MoleculeMx query,
MoleculeMx target)
{
if (query.IsBiopolymerFormat || target.IsBiopolymerFormat) // fix later
{
return(false);
}
QueryMol = query;
SSSQueryMol = CdkMolFactory.NewCdkMol(query);
SSSTargetMol = CdkMolFactory.NewCdkMol(target);
bool b = CdkMolUtil.IsSSSMatch(SSSQueryMol, SSSTargetMol);
return(b);
}
public static void SetMoleculeToTestHelmString(
string cid,
MoleculeMx mol)
{
if (!Lex.IsInteger(cid))
{
return;
}
int i1 = int.Parse(cid);
if (i1 > 0 && i1 < 10)
{
string helm = GetTestHelmString(i1);
mol.SetPrimaryTypeAndValue(MoleculeFormat.Helm, helm);
}
}
/// <summary>
/// Do a SSS using the predefined query molecule and supplied target molecule
/// </summary>
/// <returns></returns>
public bool IsFSSMatch(MoleculeMx cs)
{
if (MoleculeMx.IsUndefined(QueryMol) || MoleculeMx.IsUndefined(cs))
{
return(false);
}
if (cs.IsBiopolymerFormat)
{
return(IsFSSMatch(QueryMol, cs));
}
TargetMol = cs;
FSSTargetMol = CdkMolFactory.NewCdkMol(cs);
bool b = CdkMolUtil.IsFSSMatch(FSSTargetMol);
return(b);
}
/// <summary>
/// Map query against structure & return highlighted match
/// </summary>
/// <param name="cs"></param>
/// <returns></returns>
public MoleculeMx HighlightMatchingSubstructure(
MoleculeMx cs)
{
if (cs.IsBiopolymerFormat) // fix later
{
return(cs);
}
MoleculeMx cs2 = null;
PerformanceTimer pt = PT.Start("HighlightMatchingSubstructure");
string molfile = CdkMolUtil.HilightSSSMatch(cs.GetMolfileString());
cs2 = new MoleculeMx(MoleculeFormat.Molfile, molfile);
pt.Update();
return(cs2);
}
/// <summary>
/// Do a similarity match
/// </summary>
/// <param name="query"></param>
/// <param name="target"></param>
/// <returns></returns>
public bool FullStructureMatch(
MoleculeMx query,
MoleculeMx target,
string switches)
{
bool newQuery = (QueryMol == null || QueryMol.PrimaryValue != query.PrimaryValue);
if (newQuery)
{
QueryMol = query.Clone();
SSSQueryMol = CdkMolFactory.NewCdkMol(query);
}
SSSTargetMol = CdkMolFactory.NewCdkMol(target);
bool b = CdkMolUtil.FullStructureMatch(SSSQueryMol, SSSTargetMol, switches);
return(b);
}
/// <summary>
/// Align supplied structure to query structure
/// </summary>
/// <param name="skid"></param>
/// <returns></returns>
public MoleculeMx AlignToMatchingSubstructure(
MoleculeMx target)
{
if (target.IsBiopolymerFormat) // fix later
{
return(target);
}
MoleculeMx cs2 = null;
PerformanceTimer pt = PT.Start("AlignToMatchingSubstructure");
Stopwatch sw = Stopwatch.StartNew();
string molfile = CdkMolUtil.OrientToMatchingSubstructure(target.GetMolfileString());
cs2 = new MoleculeMx(MoleculeFormat.Molfile, molfile);
pt.Update();
return(cs2);
}
/// <summary>
/// SMILES generation for the whole HELM molecule
/// </summary>
/// <param name="helm"></param>
/// <returns></returns>
public static string HelmToSmiles(
MoleculeMx mol,
string helm)
{
string smiles = null;
if (UseWebEditor && DebugMx.False) // don't use this, only gets molfile at monomer level, not atoms/bonds
{
Browser.SetHelm(helm);
smiles = Browser.GetSmiles();
}
else
{
smiles = HelmService.GenerateSMILESForHELM(helm);
}
return(smiles);
}
/// <summary>
/// Match a structure to conditional formatting & return the first matching item
/// </summary>
/// <param name="rules"></param>
/// <param name="structure"></param>
/// <returns></returns>
public static CondFormatRule Match(
CondFormat condFormat,
MoleculeMx structure)
{
CondFormatRules rules = condFormat.Rules;
CondFormatRule rule = null;
int ri;
if (structure == null || structure.PrimaryFormat == MoleculeFormat.Unknown)
{
return(MatchNull(condFormat));
}
StructureMatcher matcher = new StructureMatcher();
for (ri = 0; ri < rules.Count; ri++) // match rules one at a time until get a hit
{
rule = rules[ri];
if (String.IsNullOrEmpty(rule.Value))
{
continue;
}
MoleculeMx query = new MoleculeMx(rule.Value);
matcher.SetSSSQueryMolecule(query);
bool matches = matcher.IsSSSMatch(structure);
//DebugLog.Message("Rule: " + ri + ", " + query.SmilesString + ", " + structure.SmilesString + ", " + matches);
if (matches)
{
break;
}
}
if (ri < rules.Count)
{
return(rule);
}
else
{
return(null);
}
}
/// <summary>
/// Convert any ChemicalStructures containing a sketch value to a ChimeString for proper serialization
/// </summary>
/// <param name="oa"></param>
public static void ConvertMoleculesToChimeStrings(object[] oa)
{
for (int ci = 0; ci < oa.Length; ci++)
{
if (!(oa[ci] is MoleculeMx))
{
continue;
}
MoleculeMx cs = oa[ci] as MoleculeMx;
if (Math.Abs(1) == 1)
{
continue; // noop for now
}
//if (cs.Type != StructureFormat.Sketch) continue; // obsolete
MoleculeFormat type = MoleculeFormat.Chime;
string value = cs.GetChimeString();
cs.SetPrimaryTypeAndValue(type, value);
}
}
public static Bitmap HelmToBitmap(
MoleculeMx mol,
int pixWidth)
{
Bitmap bm = null;
string svg = mol?.SvgString;
string msg = String.Format("mol.Id: {0}, mol.Helm: {1}", mol?.Id, mol?.HelmString);
try
{
if (mol.PrimaryFormat == MoleculeFormat.Helm && Lex.IsDefined(svg))
{ // if SVG available use it
bm = SvgUtil.GetBitmapFromSvgXml(svg, pixWidth);
if (Debug)
{
DebugLog.Message(msg + " used existing SVG");
}
return(bm);
}
else
{
string helm = mol.HelmString;
bm = HelmControl.GetBitmap(helm, pixWidth);
if (Debug)
{
DebugLog.Message(msg + " generated SVG");
}
return(bm);
}
}
catch (Exception ex)
{
msg += "\r\n" + DebugLog.FormatExceptionMessage(ex);
DebugLog.Message(msg); // log it
return(null);
}
}
/// <summary>
/// Convert Helm to Molfile format
/// </summary>
/// <param name="helm"></param>
/// <returns></returns>
public static string HelmToMolfile(
MoleculeMx mol,
string helm)
{
string molfile = null;
if (UseWebEditor)
{
lock (Browser) // lock to avoid reentrancy
{
Browser.SetHelm(helm);
molfile = Browser.GetMolfile();
}
}
else
{
return("Not Implemented");
}
return(molfile);
}
/// <summary>
/// Convert object to a MobiusDataType
/// </summary>
/// <param name="o"></param>
/// <param name="type"></param>
/// <returns></returns>
public static MobiusDataType ConvertToMobiusDataType(
MetaColumnType type,
Object o)
{
switch (type)
{
case MetaColumnType.Integer:
case MetaColumnType.Number:
case MetaColumnType.DictionaryId:
return(NumberMx.ConvertTo(o));
case MetaColumnType.QualifiedNo:
return(QualifiedNumber.ConvertTo(o));
case MetaColumnType.String:
case MetaColumnType.MolFormula:
case MetaColumnType.Hyperlink:
case MetaColumnType.Html:
case MetaColumnType.Binary:
return(StringMx.ConvertTo(o));
case MetaColumnType.Date:
return(DateTimeMx.ConvertTo(o));
case MetaColumnType.CompoundId:
return(CompoundId.ConvertTo(o));
case MetaColumnType.Structure:
return(MoleculeMx.ConvertTo(o));
case MetaColumnType.Image:
return(ImageMx.ConvertTo(o)); // assume text is dblink
default:
throw new Exception("Unrecognized data type: " + type);
}
}
/// <summary>
/// Calculate similarity score
/// </summary>
/// <param name="query"></param>
/// <param name="target"></param>
/// <returns></returns>
public double Molsim(
MoleculeMx query,
MoleculeMx target,
SimilaritySearchType type)
{
FingerprintType fpType = FingerprintType.Undefined;
if (type == SimilaritySearchType.Normal)
{
fpType = FingerprintType.MACCS;
}
else if (type == SimilaritySearchType.ECFP4)
{
fpType = FingerprintType.Circular;
}
else
{
throw new Exception("Similarity type not supported in this context: " + type);
}
bool newQuery = (QueryMol == null || QueryMol.PrimaryValue != query.PrimaryValue);
if (newQuery) // recalc query keys if query has changed
{
QueryMol = query.Clone();
QueryFingerprint = query.BuildBitSetFingerprint(fpType);
}
object targetFingerprint = target.BuildBitSetFingerprint(fpType);
double score = MoleculeMx.CalculateBitSetFingerprintSimilarity(QueryFingerprint, targetFingerprint);
return(score);
}
/// <summary>
/// Deserialize a single value object
/// </summary>
/// <param name="ba"></param>
/// <returns></returns>
public static object ReadBinaryItem(
BinaryReader br)
{
object vo = null;
VoDataType voType = (VoDataType)br.ReadByte();
switch (voType)
{
case VoDataType.Null:
return(null);
case VoDataType.DbNull:
return(DBNull.Value);
case VoDataType.Byte:
return(br.ReadByte());
case VoDataType.Int16:
return(br.ReadInt16());
case VoDataType.Int32:
return(br.ReadInt32());
case VoDataType.Int64:
return(br.ReadInt64());
case VoDataType.Float:
return(br.ReadSingle());
case VoDataType.Double:
return(br.ReadDouble());
case VoDataType.Char:
return(br.ReadChar());
case VoDataType.String:
return(br.ReadString());
case VoDataType.DateTime:
return(new DateTime(br.ReadInt64()));
case VoDataType.CompoundId:
return(CompoundId.DeserializeBinary(br));
case VoDataType.NumberMx:
return(NumberMx.DeserializeBinary(br));
case VoDataType.QualifiedNo:
return(QualifiedNumber.DeserializeBinary(br));
case VoDataType.StringMx:
return(StringMx.DeserializeBinary(br));
case VoDataType.DateTimeMx:
return(DateTimeMx.DeserializeBinary(br));
case VoDataType.ImageMx:
return(ImageMx.DeserializeBinary(br));
case VoDataType.ChemicalStructure:
return(MoleculeMx.DeserializeBinary(br));
default:
throw new Exception("Unrecognized type: " + voType);
}
}
/////////////////////////////////////////////////////////////////
//////////////////////////// Methods ////////////////////////////
/////////////////////////////////////////////////////////////////
/// <summary>
/// Create a Mobius data type based on the supplied MetaColumn type
/// </summary>
/// <param name="type"></param>
/// <returns></returns>
public static MobiusDataType New(
MetaColumnType type)
{
MobiusDataType o;
if (type == MetaColumnType.Integer)
{
o = new NumberMx();
}
else if (type == MetaColumnType.Number)
{
o = new NumberMx();
}
else if (type == MetaColumnType.QualifiedNo)
{
o = new QualifiedNumber();
}
else if (type == MetaColumnType.String)
{
o = new StringMx();
}
else if (type == MetaColumnType.Date)
{
o = new DateTimeMx();
}
else if (type == MetaColumnType.Binary)
{
o = new StringMx();
}
else if (type == MetaColumnType.CompoundId)
{
o = new CompoundId();
}
else if (type == MetaColumnType.Structure)
{
o = new MoleculeMx();
}
else if (type == MetaColumnType.MolFormula)
{
o = new StringMx();
}
else if (type == MetaColumnType.Image)
{
o = new ImageMx();
}
else if (type == MetaColumnType.DictionaryId)
{
o = new NumberMx();
}
else if (type == MetaColumnType.Hyperlink)
{
o = new StringMx();
}
else if (type == MetaColumnType.Html)
{
o = new StringMx();
}
else
{
throw new Exception("Unrecognized data type: " + type);
}
return(o);
}
/// <summary>
/// Create CdkMol instance from MoleculeMx
/// </summary>
/// <param name="molMx"></param>
/// <returns></returns>
public static INativeMolMx NewCdkMol(MoleculeMx molMx)
{
return(I.NewCdkMol(molMx));
}
/// <summary>
/// Custom compact Deserialization of MobiusDataType
/// </summary>
/// <returns></returns>
public static MobiusDataType Deserialize(string[] sa)
{
int sai;
MobiusDataType mdt = null;
char type = sa[0][0];
sai = 5; // first array entry for specific subclass
switch (type)
{
case 'M': // ChemicalStructure (Molecule)
mdt = MoleculeMx.Deserialize(sa, sai);
break;
case 'C': // CompoundId
mdt = CompoundId.Deserialize(sa, sai);
break;
case 'D': // DateTimeEx
mdt = DateTimeMx.Deserialize(sa, sai);
break;
case 'I': // ImageEx
mdt = ImageMx.Deserialize(sa, sai);
break;
case 'N': //NumberEx
mdt = NumberMx.Deserialize(sa, sai);
break;
case 'Q': // QualifiedNumber
mdt = QualifiedNumber.Deserialize(sa, sai);
break;
case 'S': // StringEx
mdt = StringMx.Deserialize(sa, sai);
break;
default:
throw new Exception("Unexpected MobiusDataType: " + type);
}
if (!Lex.IsNullOrEmpty(sa[1]))
{
mdt.BackColor = Color.FromArgb(int.Parse(sa[1]));
}
if (!Lex.IsNullOrEmpty(sa[2]))
{
mdt.ForeColor = Color.FromArgb(int.Parse(sa[2]));
}
if (!Lex.IsNullOrEmpty(sa[3]))
{
mdt.DbLink = sa[3];
}
if (!Lex.IsNullOrEmpty(sa[4]))
{
mdt.Hyperlink = sa[4];
}
return(mdt);
}
