public static void LoadFrom(FeatureItem FeatureItem)
{
if (FeatureItem.Project == null) return;
new Project { DTEProject = FeatureItem.Project }
.Load();
}
public static RaconteurGenerator NewRaconteurGenerator(FeatureItem FeatureItem)
{
return new RaconteurGeneratorClass
{
FeatureItem = FeatureItem,
FeatureParser = NewFeatureParser,
};
}
private IEnumerable<FeatureItem> GetFeatures(IPrincipal principal)
{
var module0 = new FeatureItem { Module = "Articles", DisplayText = "INDEX_ARTICLES", Url = "/articles", MatchPattern = "(/article.*)", Users = new List<string> { "cw", "bob" } };
var module1 = new FeatureItem { Module = "ArticleDetails", Url = "/articledetails/:id", Users = new List<string> { "cw", "bob" } };
var module2 = new FeatureItem { Module = "Gallery", DisplayText = "INDEX_GALLERY", Url = "/gallery", MatchPattern = "/gallery", Users = new List<string> { "cw" } };
var module3 = new FeatureItem { Module = "Log", DisplayText = "INDEX_LOGS", Url = "/log", MatchPattern = "/log", Users = new List<string> { "cw" } };
var module4 = new FeatureItem { Module = "Statistics", DisplayText = "INDEX_STATS", Url = "/stats", MatchPattern = "/stats", Users = new List<string> { "cw", "bob" } };
return new List<FeatureItem> { module0, module1, module2, module3, module4 }.Where(m => m.Users.Contains(principal.Identity.Name));
}
public static Project LoadFrom(FeatureItem FeatureItem)
{
if (FeatureItem.Project == null) return null;
var Result = new Project { DTEProject = FeatureItem.Project };
Result.Load();
return Result;
}
public void Compile(Feature Feature, FeatureItem FeatureItem)
{
if (Feature is InvalidFeature) return;
this.Feature = Feature;
LoadAssemblies(FeatureItem);
CompileFeature();
CompileSteps();
}
public static RaconteurGenerator NewRaconteurGenerator(FeatureItem FeatureItem)
{
return new RaconteurGeneratorClass
{
FeatureItem = FeatureItem,
FeatureParser = NewFeatureParser,
RunnerGenerator = new RunnerGenerator(),
StepDefinitionsGenerator = new StepDefinitionsGenerator(),
};
}
public void SetUp()
{
FeatureItem = Create.TestObjectFor<FeatureItem>();
Generator = new RaconteurSingleFileGenerator
{
FeatureItem = FeatureItem,
CodeFilePath = "Feature"
};
}
public void SetUp()
{
FeatureItem = Substitute.For<FeatureItem>();
Generator = new RaconteurSingleFileGenerator
{
FeatureItem = FeatureItem,
CodeFilePath = "Feature"
};
}
public virtual IEnumerable<string> StepNamesOf(Feature Feature, FeatureItem FeatureItem)
{
if (Feature is InvalidFeature) return new List<string>();
this.Feature = Feature;
LoadAssemblies(FeatureItem);
return StepDefinitions.SelectMany(type =>
type.GetMethods(BindingFlags.Public | BindingFlags.Instance)
.Select(method => method.Name.InNaturalLanguage()));
}
public Feature FeatureFrom(FeatureFile FeatureFile, FeatureItem FeatureItem)
{
if (FeatureFile == null) return new Feature();
Content = FeatureFile.Content;
return new Feature
{
FileName = FeatureFile.Name,
Namespace = FeatureItem.DefaultNamespace,
Name = Name,
Scenarios = ScenarioParser.ScenariosFrom(Content)
};
}
private static void fill_feature(FeatureItem fe, long id)
{
//this query is inconsistent with other beacause other approach creates and error;
Feature feat = new Feature(fe, id);
MySqlCommand cmmd14 = new MySqlCommand(feat.get_query(), conn);
MySqlDataReader reader14 = cmmd14.ExecuteReader();
reader14.Close();
long feature_id = cmmd14.LastInsertedId;
foreach (var qua in fe.Qualifiers)
{
long qualifier_id = fill_qualifier(qua.Key, feature_id);
foreach (var v in qua.Value)
{
fill_qualifier_value(v.ToString(), qualifier_id);
}
}
}
private static void fill_feature(FeatureItem feature, long id)
{
Feature feat = new Feature(feature, id);
MySqlCommand cmmd14 = new MySqlCommand(feat.get_query(), conn);
MySqlDataReader reader14 = cmmd14.ExecuteReader();
reader14.Close();
long feature_id = cmmd14.LastInsertedId;
foreach (var q in feature.Qualifiers)
{
long qualifier_id = fill_qualifier(q.Key, feature_id);
foreach (var qv in q.Value)
{
//Console.WriteLine("{0}", qualifier_id);
fill_qualifier_value(qv.ToString(), qualifier_id);
}
}
}
public IList <FeatureItem> ProcessFeatureItems()
{
try
{
var doc = Autodesk.AutoCAD.ApplicationServices.Core.Application.DocumentManager.MdiActiveDocument;
using (Autodesk.AutoCAD.DatabaseServices.Database db = doc.Database)
{
var features = new List <FeatureItem>();
var pid = GetPolylineEntityIDs(db);
var temp = new List <Polyline>();
foreach (ObjectId item in pid)
{
using (OpenCloseTransaction tr = db.TransactionManager.StartOpenCloseTransaction())
{
Polyline pline = (Polyline)tr.GetObject(item, OpenMode.ForWrite);
temp.Add(pline);
tr.Commit();
}
}
var distpolys = temp.Select(p => p.Layer).Distinct();
foreach (var item in distpolys)
{
var feature = new FeatureItem();
feature.active = true;
feature.layer = item;
feature.name = GetShortLayerName(item);
feature.count = temp.Count(p => p.Layer == item);
features.Add(feature);
}
return(features);
}
}
catch (System.Exception ex)
{
COMS.MessengerManager.LogException(ex);
}
return(null);
}
public static FeatureItem ToDomain(this FeatureItemDto dto, FeatureItem originalEntity = null)
{
if (originalEntity != null && originalEntity.Id == dto.Id)
{
originalEntity.FeatureId = dto.FeatureId;
originalEntity.ItemId = dto.ItemId;
((IDataDto)dto).ToDomain((IData)originalEntity);
return(originalEntity);
}
var data = new FeatureItem
{
FeatureId = dto.FeatureId,
ItemId = dto.ItemId,
};
((IDataDto)dto).ToDomain((IData)data);
return(data);
}
/// <summary>
/// Get the feature value
/// </summary>
/// <param name="featureID">featureID</param>
/// <param name="featureSetID">file name</param>
/// <returns></returns>
public static string GetFeature(string featureID, string featureSetID)
{
XElement featureXml = FeatureItem.Get(featureSetID).Value;
IEnumerable <XElement> featureList = featureXml.XPathSelectElements("Feature[@ID='" + featureID + "']");
if (featureList.Any())
{
if (featureList.Count() > 1)
{
return(featureList.Where(
x => x.Attribute("Environment") != null &&
x.Attribute("Environment").Value == ConfigurationManager.AppSettings["Environment"]
).First().Value);
}
else
{
return(featureList.First().Value);
}
}
return(string.Empty);
}
public void CreateFeatureItemList(int parentId, float rmp)
{
//获取一级元素
List <DirverRelation> dirvers = _dirverRelationList.FindAll(x => x.ParentId == parentId);
if (dirvers != null && dirvers.Count > 0)
{
foreach (DirverRelation dirver in dirvers)
{
//获取同类的设备集合
object value = null;
if (_unitList.ContainsKey(dirver.DType))
{
value = _unitList[dirver.DType];
}
FeatureItem item = GetFeatureItem(dirver, value, dirver.DType, dirver.DId, (int)rmp);
_featureItemList.Add(item);
CreateFeatureItemList(dirver.DrId, item.FOutSpeed);
}
}
}
public void SetSkeletonFromHandPos(KDTree <float, int> tree, LinkedList <FeatureItem> features, string handName, int k)
{
float[] featureVec = new float[featureVectorLength];
Transform headTransform = rootBone.transform.Find("LowerBack/Spine/Spine1/Neck/Neck1/Head");
Transform neckTransform = rootBone.transform.Find("LowerBack/Spine/Spine1/Neck/Neck1/Head");
rootBone.transform.position -= headTransform.position;
float handTargetSpPositionAngle = SphericalCoords.GetYRotFromVec(features.Last().position) * Mathf.Rad2Deg;
var currFeatureContainer = features.Last;
Debug.Assert(featureVectorLength % 9 == 0);
for (int i = 0; i < featureVectorLength / 9; i++)
{
FeatureItem currFeatureItem = currFeatureContainer.Value;
Vector3 handPos = currFeatureItem.position;
Vector3 handVel = currFeatureItem.velocity;
Vector3 handAcc = currFeatureItem.acceleration;
if (ignoreRotation)
{
float handYRotValue = SphericalCoords.GetYRotFromVec(handPos) * Mathf.Rad2Deg;
SphericalCoords sphCoords = SphericalCoords.CartesianToSpherical(handPos);
sphCoords.theta = 0;
Vector3 outVec = sphCoords.ToCartesian();
handPos = Quaternion.AngleAxis(handYRotValue, Vector3.up) * handPos;
handVel = Quaternion.AngleAxis(handYRotValue, Vector3.up) * handVel;
handAcc = Quaternion.AngleAxis(handYRotValue, Vector3.up) * handAcc;
}
int startIndex = 9 * i;
featureVec[startIndex] = handPos.x;
featureVec[startIndex + 1] = handPos.y;
featureVec[startIndex + 2] = handPos.z;
featureVec[startIndex + 3] = handVel.x;
featureVec[startIndex + 4] = handVel.y;
featureVec[startIndex + 5] = handVel.z;
featureVec[startIndex + 6] = handAcc.x;
featureVec[startIndex + 7] = handAcc.y;
featureVec[startIndex + 8] = handAcc.z;
if (currFeatureContainer.Previous != null)
{
currFeatureContainer = currFeatureContainer.Previous;
}
}
Tuple <float[], int>[] poseIndices = tree.NearestNeighbors(featureVec, k);
int index = poseIndices[0].Item2;
RotationIndex[] rotations = new RotationIndex[poseIndices.Length];
for (int i = 0; i < poseIndices.Length; i++)
{
double distance = Metrics.WeightedL2Norm(poseIndices[i].Item1, featureVec);
RotationIndex currIdx = new RotationIndex(poseIndices[i].Item2, (float)(1.0 / distance));
rotations[i] = currIdx;
}
rootBone.SetToRotations(rotations);
//rootBone.SetToRotation(index);
Transform handTransform = rootBone.transform.Find(handName);
SphericalCoords handTransformSpPosition = SphericalCoords.CartesianToSpherical(handTransform.position - headTransform.position);
float handTransformSpPositionAngle = handTransformSpPosition.theta * Mathf.Rad2Deg;
rootBone.transform.localRotation *= Quaternion.Euler(0, -handTargetSpPositionAngle + handTransformSpPositionAngle, 0);
}
void LoadAssemblies(FeatureItem FeatureItem)
{
Assemblies = new List<string> {FeatureItem.Assembly};
Assemblies.AddRange(Settings.Libraries);
}
void SetUpFeatureItem()
{
FeatureItem = Substitute.For<FeatureItem>();
FeatureItem.Assembly.Returns("Common");
}
/// <summary>
/// Create subsequences from features
/// and non-coding subsequences from gaps.
/// </summary>
/// <returns>
/// Returns tuple of coding and non-coding features count.
/// </returns>
private (int, int) CreateFeatureSubsequences()
{
var codingSubsequences = new List <Subsequence>(features.Count);
var newPositions = new List <Position>();
var newSequenceAttributes = new List <SequenceAttribute>();
for (int i = 1; i < features.Count; i++)
{
FeatureItem feature = features[i];
ILocation location = feature.Location;
List <ILocation> leafLocations = location.GetLeafLocations();
Feature subsequenceFeature;
if (feature.Key == gene)
{
if (allNonGenesLeafLocations.Any(l => LocationsEqual(leafLocations, l)))
{
continue;
}
subsequenceFeature = Feature.Gene;
}
else
{
subsequenceFeature = FeatureRepository.GetFeatureByName(feature.Key);
}
if (feature.Qualifiers.ContainsKey(LibiadaWeb.Attribute.Pseudo.GetDisplayValue()) ||
feature.Qualifiers.ContainsKey(LibiadaWeb.Attribute.Pseudogene.GetDisplayValue()))
{
subsequenceFeature = Feature.PseudoGen;
}
bool partial = CheckPartial(leafLocations);
bool complement = location.Operator == LocationOperator.Complement;
bool join = leafLocations.Count > 1;
bool complementJoin = join && complement;
if (location.SubLocations.Count > 0)
{
complement = complement || location.SubLocations[0].Operator == LocationOperator.Complement;
}
int start = leafLocations[0].LocationStart - 1;
int end = leafLocations[0].LocationEnd - 1;
int length = end - start + 1;
var subsequence = new Subsequence
{
Id = db.GetNewElementId(),
Feature = subsequenceFeature,
Partial = partial,
SequenceId = sequenceId,
Start = start,
Length = length,
RemoteId = location.Accession
};
codingSubsequences.Add(subsequence);
AddPositionToMap(start, end);
newPositions.AddRange(CreateAdditionalPositions(leafLocations, subsequence.Id));
var sequenceAttributes = sequenceAttributeRepository.Create(feature.Qualifiers, complement, complementJoin, subsequence);
newSequenceAttributes.AddRange(sequenceAttributes);
}
var nonCodingSubsequences = CreateNonCodingSubsequences();
db.Subsequence.AddRange(codingSubsequences);
db.Subsequence.AddRange(nonCodingSubsequences);
db.Position.AddRange(newPositions);
db.SequenceAttribute.AddRange(newSequenceAttributes);
db.SaveChanges();
return(codingSubsequences.Count, nonCodingSubsequences.Count);
}
private static List<FeatureItem> loadFeaturesFile()
{
Assembly executingAssembly = Assembly.GetExecutingAssembly();
executingAssembly.GetManifestResourceNames();
Stream manifestResourceStream = executingAssembly.GetManifestResourceStream("NewWDS.WDS_Resources.Features.xml");
XmlDocument document = new XmlDocument();
document.Load(manifestResourceStream);
XmlNode feature_table = document.SelectSingleNode("/Feature_Table");
List<FeatureItem> list = new List<FeatureItem>();
foreach (XmlNode feature_record in feature_table.ChildNodes)
{
FeatureItem item = new FeatureItem();
foreach (XmlNode featureName in feature_record.ChildNodes)
{
string name = featureName.Name;
if (name != null)
{
if (name == "LicenseCode")
item.LicenseCode = featureName.InnerText;
else if (name == "FeatureName")
item.FeatureName = featureName.InnerText;
}
}
if (LicenseManager.instance().checkLicenseNameIntegrity(item.FeatureName, false, true))
list.Add(item);
}
return list;
}
private bool DDJC()
{
try
{
if (_featureLayer == null)
{
return(false);
}
_featureItems = new List <FeatureItem>();
// 遍历所有点
IFeatureCursor pFeatureCursor = _featureLayer.Search(null, false);
IFeature pFeature;
while ((pFeature = pFeatureCursor.NextFeature()) != null)
{
_featureItems.Add(new FeatureItem(pFeature));
}
Marshal.ReleaseComObject(pFeatureCursor);
// 过滤重复点
for (int i = 0; i <= _featureItems.Count - 1; i++)
{
FeatureItem featureItem = _featureItems[i];
ISpatialFilter pSpatialFilter = new SpatialFilterClass();
pSpatialFilter.Geometry = featureItem.MainFeature.Shape;
pSpatialFilter.GeometryField = _featureLayer.FeatureClass.ShapeFieldName;
pSpatialFilter.SpatialRel = esriSpatialRelEnum.esriSpatialRelIntersects;
pSpatialFilter.OutputSpatialReference[_featureLayer.FeatureClass.ShapeFieldName] =
_context.FocusMap.SpatialReference;
pFeatureCursor = _featureLayer.Search(pSpatialFilter, false);
while ((pFeature = pFeatureCursor.NextFeature()) != null)
{
if (featureItem.OID == pFeature.OID)
{
continue;
}
bool isSame = true;
foreach (KeyValuePair <int, IField> selectedField in _selectedFields)
{
object objFeature1 = featureItem.MainFeature.Value[selectedField.Key];
object objFeature2 = pFeature.Value[selectedField.Key];
if (objFeature1 is DBNull && objFeature2 is DBNull)
{
continue;
}
if (objFeature1 is DBNull || objFeature2 is DBNull)
{
isSame = false;
break;
}
if (objFeature1.ToString().Equals(objFeature2.ToString()))
{
continue;
}
isSame = false;
break;
}
if (isSame) // 相同 重复点
{
_featureItems.Remove(_featureItems.FirstOrDefault(c => c.OID == pFeature.OID));
featureItem.SubFeatureItems.Add(new FeatureItem(pFeature));
featureItem.Name = $"重复个数 {featureItem.SubFeatureItems.Count}";
}
}
}
for (int i = _featureItems.Count - 1; i >= 0; i--)
{
FeatureItem feature = _featureItems[i];
if (feature.SubFeatureItems.Count == 0)
{
_featureItems.Remove(feature);
}
}
if (_featureItems.Any())
{
MessageBox.Show(@"检查完毕", @"提示");
return(true);
}
else
{
MessageBox.Show(@"检查完毕，未发现任何问题", @"提示");
return(false);
}
}
catch (Exception exception)
{
MessageBox.Show(exception.Message);
return(false);
}
}
//public static Facet CreateFacet(string fName, string fType, BlastSearchRecord rec, int hitId, int hspId, ISequence gb, Item item, string NCBIurl, CodingSequence bestCds, int rank)
public static Facet CreateFacet(string fName, string fType, BlastSearchRecord rec, int hitId, int hspId, ISequence gb, Item item, string NCBIurl, FeatureItem bestItem, int rank)
{
Hit hit = rec.Hits[hitId];
Hsp hsp = hit.Hsps[hspId];
GenBankMetadata gbMeta = (GenBankMetadata)gb.Metadata["GenBank"];
string[] classLevels;
switch (fName)
{
case "QueryName":
return(new Facet(fName, fType, item.Name));
case "QueryLen":
return(new Facet(fName, fType, rec.IterationQueryLength));
case "Rank":
return(new Facet(fName, fType, rank));
case "Score":
return(new Facet(fName, fType, Math.Round(hsp.BitScore, 1)));
case "Identity":
double pi = (hsp.IdentitiesCount / (double)hsp.AlignmentLength) * 100.0;
return(new Facet(fName, fType, Math.Round(pi, 0)));
case "Span":
double sp = ((hsp.QueryEnd - hsp.QueryStart + 1) / (double)rec.IterationQueryLength) * 100.0;
return(new Facet(fName, fType, Math.Round(sp, 0)));
case "SubjStart":
double subjStart = hsp.HitStart;
return(new Facet(fName, fType, Math.Round(subjStart, 0)));
case "SubjLen":
double subjLen = hit.Length;
return(new Facet(fName, fType, Math.Round(subjLen, 0)));
case "Strand":
string strand = FrameToStrand(hsp.QueryFrame) + "/" + FrameToStrand(hsp.HitFrame);
return(new Facet(fName, fType, strand));
case "Species":
int index = gbMeta.Source.Organism.Species.IndexOf(" ", StringComparison.Ordinal);
if (index > 0)
{
return(new Facet(fName, fType, gbMeta.Source.Organism.Genus + " " + gbMeta.Source.Organism.Species.Substring(0, index)));
}
else
{
return(new Facet(fName, fType, gbMeta.Source.Organism.Genus + " " + gbMeta.Source.Organism.Species));
}
case "Kingdom":
classLevels = gbMeta.Source.Organism.ClassLevels.Split(';');
if (classLevels.Length >= 1)
{
return(new Facet(fName, fType, classLevels[0]));
}
else
{
return(new Facet(fName, fType, "N/A"));
}
case "Phylum":
classLevels = gbMeta.Source.Organism.ClassLevels.Split(';');
if (classLevels.Length >= 2)
{
return(new Facet(fName, fType, classLevels[1]));
}
else
{
return(new Facet(fName, fType, "N/A"));
}
case "Class":
classLevels = gbMeta.Source.Organism.ClassLevels.Split(';');
if (classLevels.Length >= 3)
{
return(new Facet(fName, fType, classLevels[2]));
}
else
{
return(new Facet(fName, fType, "N/A"));
}
case "Order":
classLevels = gbMeta.Source.Organism.ClassLevels.Split(';');
if (classLevels.Length >= 4)
{
return(new Facet(fName, fType, classLevels[3]));
}
else
{
return(new Facet(fName, fType, "N/A"));
}
case "Family":
classLevels = gbMeta.Source.Organism.ClassLevels.Split(';');
if (classLevels.Length >= 5)
{
return(new Facet(fName, fType, classLevels[4]));
}
else
{
return(new Facet(fName, fType, "N/A"));
}
case "Lineage":
return(new Facet(fName, fType, gbMeta.Source.Organism.ClassLevels.ToString()));
case "Organism":
return(new Facet(fName, fType, gbMeta.Source.CommonName));
// return new Facet(fName, fType, gbMeta.Source.Organism.Genus + " " + gbMeta.Source.Organism.Species);
case "Genus":
return(new Facet(fName, fType, gbMeta.Source.Organism.ClassLevels.Split(';').Last().Trim().TrimEnd('.')));
case "Gene":
string name = "N/A";
//if (bestCds != null)
if (bestItem != null)
{
//CodingSequence feature = bestCds;
FeatureItem feature = bestItem;
String geneSym = "N/A";
foreach (KeyValuePair <string, List <String> > qualifier in feature.Qualifiers)
{
if (qualifier.Key == "gene")
{
geneSym = qualifier.Value[0].ToString().Trim('"');
}
}
if (geneSym != "")
{
name = geneSym;
string url2 = System.Web.HttpUtility.HtmlEncode("http://www.ncbi.nlm.nih.gov/sites/entrez?cmd=search&db=gene&term=" + name + "%5Bsym%5D");
return(new Facet(fName, fType, name, url2));
}
}
return(new Facet(fName, fType, name, null));
case "GI":
return(new Facet(fName, fType, gbMeta.Version.GINumber, NCBIurl + gbMeta.Version.GINumber));
case "Accession":
return(new Facet(fName, fType, gbMeta.Version.CompoundAccession, NCBIurl + gbMeta.Version.CompoundAccession));
case "Definition":
return(new Facet(fName, fType, gbMeta.Definition));
case "EValue":
return(new Facet(fName, fType, String.Format("{0:#e+00}", hsp.EValue)));
case "AlignLen":
return(new Facet(fName, fType, hsp.AlignmentLength, @"txt\" + item.Id + ".txt"));
case "RefCount":
int i = 0;
foreach (CitationReference r in gbMeta.References)
{
if ((r.Title != "Direct Submission") && (r.Journal != "Unpublished"))
{
i++;
}
}
return(new Facet(fName, fType, i));
case "References":
if (gbMeta.References.Count() == 0)
{
return(new Facet(fName, fType));
}
string url = CreateReferenceURL(gbMeta.References[0]);
Facet f = new Facet(fName, fType);
if (gbMeta.References.Count() > 0)
{
int j = 1;
foreach (CitationReference r in gbMeta.References)
{
if (r.Title != "Direct Submission" && (r.Journal != "Unpublished"))
{
url = CreateReferenceURL(r);
f.Add(new FacetValue(f.Type, String.Format("{0}. {1}. {2}.", j, r.Title, r.Journal), url));
j++;
}
}
}
return(f);
case "SubmissionDate":
DateTime dt = new DateTime(gbMeta.Locus.Date.Year, gbMeta.Locus.Date.Month, gbMeta.Locus.Date.Day);
return(new Facet(fName, fType, dt.ToUniversalTime().ToString("o")));
case "Product":
Facet productFacet = new Facet(fName, fType, GetQualifierString("Protein", "product", gbMeta));
if (productFacet[0].Value == "N/A")
{
Console.WriteLine(productFacet[0].Value + "!!!!!!!!!!!!!!!!!!!!!!!!!!***********");
if (bestItem != null)
{
productFacet = new Facet(fName, fType, GetQualifierStringFromCDS(bestItem, "product"));
}
Console.WriteLine(productFacet[0].Value + "!!!!!!!!!!!!!!!!!!!!!!!!&&&&&&&&&&&&&");
}
return(productFacet);
case "Function":
Facet funcFacet = new Facet(fName, fType, GetQualifierString("Protein", "function", gbMeta));
if (funcFacet[0].Value == "N/A")
{
if (bestItem != null)
{
funcFacet = new Facet(fName, fType, GetQualifierStringFromCDS(bestItem, "function"));
}
}
return(funcFacet);
default:
throw (new Exception("Facet category with name = " + fName + " does not exist."));
}
}
public static int[] GetBestAnnotatedIndex(UIParameters Up, int seqPos)
{
// BLAST reports are saved in individual files by query and
// numbered in the same order as they appear in the input FASTA file.
int[] annotatedIndex = new int[2];
annotatedIndex[0] = -1;
annotatedIndex[1] = -1;
string blastFile = Up.ProjectDir + "\\xml\\" + seqPos + ".xml";
if (!File.Exists(blastFile))
{
throw new Exception("File does not exist.");
}
BlastXmlParser blastParser = new BlastXmlParser();
IList <BlastResult> blastResults = blastParser.Parse(blastFile);
GenBankParser gbParser = new GenBankParser();
// iterate through the BLAST results.
foreach (BlastResult blastResult in blastResults)
{
foreach (BlastSearchRecord record in blastResult.Records)
{
int hitsProcessed = 0;
// If there are not hits in the BLAST result ...
int rank = 0;
if (record.Hits.Count() > 0)
{
// For each hit
for (int i = 0; i < record.Hits.Count(); i++)
{
Hit blastHit = record.Hits[i];
for (int j = 0; j < blastHit.Hsps.Count(); j++)
{
Hsp blastHsp = blastHit.Hsps[j];
double percentId = (blastHsp.IdentitiesCount / (double)blastHsp.AlignmentLength) * 100;
double queryCoverage = ((double)(blastHsp.QueryEnd - blastHsp.QueryStart + 1) / record.IterationQueryLength) * 100;
if ((percentId >= Up.BlastMinPercentIdentity) &&
(Up.BlastMaxEvalue >= blastHsp.EValue) &&
(queryCoverage >= Up.BlastMinPercentQueryCoverage) &&
(hitsProcessed < Up.BlastMaxNumHits))
{
rank += 1;
long gi = Convert.ToInt64(blastHit.Id.Split('|')[1]);
GenBankItem gitem = new GenBankItem(gi, blastHsp.HitStart, blastHsp.HitEnd);
string gbFile = Up.ProjectDir + "\\gb\\" + gitem.Id.ToString();
gbFile += "_" + gitem.HitStart.ToString();
gbFile += "_" + gitem.HitEnd.ToString();
gbFile += ".gb";
try
{
Console.WriteLine("GB OK: " + record.Hits[0].Id + " " + i.ToString() + " " + j.ToString());
ISequence gbRecord = gbParser.ParseOne(gbFile);
GenBankMetadata gbMeta = (GenBankMetadata)gbRecord.Metadata["GenBank"];
IList <FeatureItem> features = gbMeta.Features.All;
FeatureItem bestItem = getBestFeatureItem(features);
if (bestItem != null)
{
annotatedIndex[0] = i;
annotatedIndex[1] = j;
return(annotatedIndex);
}
}
catch
{
Console.WriteLine("ISANNOTATED: " + record.Hits[0].Id + " " + i.ToString() + " " + j.ToString());
}
hitsProcessed += 1;
}
}
}
}
}
}
return(annotatedIndex);
}
//public static Facet CreateFacet(string fName, string fType, BlastSearchRecord rec, int hitId, int hspId, ISequence gb, Item item, string NCBIurl, CodingSequence bestCds, int rank)
public static Facet CreateFacet(string fName, string fType, BlastSearchRecord rec, int hitId, int hspId, ISequence gb, Item item, string NCBIurl, FeatureItem bestItem, int rank)
{
Hit hit = rec.Hits[hitId];
Hsp hsp = hit.Hsps[hspId];
GenBankMetadata gbMeta = (GenBankMetadata)gb.Metadata["GenBank"];
string[] classLevels;
switch (fName)
{
case "QueryName":
return new Facet(fName, fType, item.Name);
case "QueryLen":
return new Facet(fName, fType, rec.IterationQueryLength);
case "Rank":
return new Facet(fName, fType, rank);
case "Score":
return new Facet(fName, fType, Math.Round(hsp.BitScore, 1));
case "Identity":
double pi = (hsp.IdentitiesCount / (double)hsp.AlignmentLength) * 100.0;
return new Facet(fName, fType, Math.Round(pi, 0));
case "Span":
double sp = ((hsp.QueryEnd - hsp.QueryStart + 1) / (double)rec.IterationQueryLength) * 100.0;
return new Facet(fName, fType, Math.Round(sp, 0));
case "SubjStart":
double subjStart = hsp.HitStart;
return new Facet(fName, fType, Math.Round(subjStart,0));
case "SubjLen":
double subjLen = hit.Length;
return new Facet(fName, fType, Math.Round(subjLen, 0));
case "Strand":
string strand = FrameToStrand(hsp.QueryFrame) + "/" + FrameToStrand(hsp.HitFrame);
return new Facet(fName, fType, strand);
case "Species":
int index = gbMeta.Source.Organism.Species.IndexOf(" ", StringComparison.Ordinal);
if (index > 0)
{
return new Facet(fName, fType, gbMeta.Source.Organism.Genus + " " + gbMeta.Source.Organism.Species.Substring(0, index));
}
else
{
return new Facet(fName, fType, gbMeta.Source.Organism.Genus + " " + gbMeta.Source.Organism.Species);
}
case "Kingdom":
classLevels = gbMeta.Source.Organism.ClassLevels.Split(';');
if (classLevels.Length >= 1)
{
return new Facet(fName, fType, classLevels[0]);
}
else
{
return new Facet(fName, fType, "N/A");
}
case "Phylum":
classLevels = gbMeta.Source.Organism.ClassLevels.Split(';');
if (classLevels.Length >= 2)
{
return new Facet(fName, fType, classLevels[1]);
}
else
{
return new Facet(fName, fType, "N/A");
}
case "Class":
classLevels = gbMeta.Source.Organism.ClassLevels.Split(';');
if (classLevels.Length >= 3)
{
return new Facet(fName, fType, classLevels[2]);
}
else
{
return new Facet(fName, fType, "N/A");
}
case "Order":
classLevels = gbMeta.Source.Organism.ClassLevels.Split(';');
if (classLevels.Length >= 4)
{
return new Facet(fName, fType, classLevels[3]);
}
else
{
return new Facet(fName, fType, "N/A");
}
case "Family":
classLevels = gbMeta.Source.Organism.ClassLevels.Split(';');
if (classLevels.Length >= 5)
{
return new Facet(fName, fType, classLevels[4]);
}
else
{
return new Facet(fName, fType, "N/A");
}
case "Lineage":
return new Facet(fName, fType, gbMeta.Source.Organism.ClassLevels.ToString());
case "Organism":
return new Facet(fName, fType, gbMeta.Source.CommonName);
// return new Facet(fName, fType, gbMeta.Source.Organism.Genus + " " + gbMeta.Source.Organism.Species);
case "Genus":
return new Facet(fName, fType, gbMeta.Source.Organism.ClassLevels.Split(';').Last().Trim().TrimEnd('.'));
case "Gene":
string name = "N/A";
//if (bestCds != null)
if (bestItem != null)
{
//CodingSequence feature = bestCds;
FeatureItem feature = bestItem;
String geneSym = "N/A";
foreach (KeyValuePair<string,List<String>> qualifier in feature.Qualifiers){
if (qualifier.Key == "gene")
{
geneSym = qualifier.Value[0].ToString().Trim('"');
}
}
if (geneSym != "")
{
name = geneSym;
string url2 = System.Web.HttpUtility.HtmlEncode("http://www.ncbi.nlm.nih.gov/sites/entrez?cmd=search&db=gene&term=" + name + "%5Bsym%5D");
return new Facet(fName, fType, name, url2);
}
}
return new Facet(fName, fType, name, null);
case "GI":
return new Facet(fName, fType, gbMeta.Version.GINumber, NCBIurl + gbMeta.Version.GINumber);
case "Accession":
return new Facet(fName, fType, gbMeta.Version.CompoundAccession, NCBIurl + gbMeta.Version.CompoundAccession);
case "Definition":
return new Facet(fName, fType, gbMeta.Definition);
case "EValue":
return new Facet(fName, fType, String.Format("{0:#e+00}", hsp.EValue));
case "AlignLen":
return new Facet(fName, fType, hsp.AlignmentLength, @"txt\" + item.Id + ".txt");
case "RefCount":
int i = 0;
foreach (CitationReference r in gbMeta.References)
{
if ((r.Title != "Direct Submission") && (r.Journal != "Unpublished")) { i++; }
}
return new Facet(fName, fType, i);
case "References":
if (gbMeta.References.Count() == 0)
{
return new Facet(fName, fType);
}
string url = CreateReferenceURL(gbMeta.References[0]);
Facet f = new Facet(fName, fType);
if (gbMeta.References.Count() > 0)
{
int j = 1;
foreach (CitationReference r in gbMeta.References)
{
if (r.Title != "Direct Submission" && (r.Journal != "Unpublished"))
{
url = CreateReferenceURL(r);
f.Add(new FacetValue(f.Type, String.Format("{0}. {1}. {2}.", j, r.Title, r.Journal), url));
j++;
}
}
}
return f;
case "SubmissionDate":
DateTime dt = new DateTime(gbMeta.Locus.Date.Year, gbMeta.Locus.Date.Month, gbMeta.Locus.Date.Day);
return new Facet(fName, fType, dt.ToUniversalTime().ToString("o"));
case "Product":
Facet productFacet = new Facet(fName, fType, GetQualifierString("Protein", "product", gbMeta));
if (productFacet[0].Value == "N/A")
{
Console.WriteLine(productFacet[0].Value + "!!!!!!!!!!!!!!!!!!!!!!!!!!***********");
if (bestItem != null) { productFacet = new Facet(fName, fType, GetQualifierStringFromCDS(bestItem, "product")); }
Console.WriteLine(productFacet[0].Value + "!!!!!!!!!!!!!!!!!!!!!!!!&&&&&&&&&&&&&");
}
return productFacet;
case "Function":
Facet funcFacet = new Facet(fName, fType, GetQualifierString("Protein", "function", gbMeta));
if (funcFacet[0].Value == "N/A")
{
if (bestItem != null) { funcFacet = new Facet(fName, fType, GetQualifierStringFromCDS(bestItem, "function")); }
}
return funcFacet;
default:
throw (new Exception("Facet category with name = " + fName + " does not exist."));
}
}
public Feature FeatureFrom(FeatureFile FeatureFile, FeatureItem FeatureItem)
{
Content = FeatureFile.Content.TrimLines();
Assembly = FeatureItem.Assembly;
if (IsNotAValidFeature) return InvalidFeature;
return new Feature
{
FileName = FeatureFile.Name,
Namespace = FeatureItem.DefaultNamespace,
Name = Name,
Scenarios = ScenarioTokenizer.ScenariosFrom(Content),
StepLibraries = StepLibraries
};
}
public Feature FeatureFrom(FeatureFile FeatureFile, FeatureItem FeatureItem)
{
return(ParseFeature(FeatureFile.Name, FeatureFile.Content, FeatureItem));
}
public IActionResult Create(FeatureItem featureItem)
{
var result = _repositoryCreateConductor.Create(featureItem);
return(Ok(result));
}
/// <summary>
/// 获取特征频率
/// </summary>
/// <param name="nType">元件类型</param>
/// <param name="element">元件</param>
/// <param name="Input">输入转速</param>
/// <param name="OutPut"></param>
/// <returns></returns>
public FeatureItem GetFeatureItem(int nType, object element, float Input)
{
if (element == null)
{
return(null);
}
FeatureItem featureItem = null;
switch (nType)
{
case 1:
#region 电动机
DirverMotor motor = element as DirverMotor;
featureItem = new FeatureItem()
{
FInSpeed = Input,
FOutSpeed = Input,
FKey = motor.DmId,
FName = motor.DmName,
FMark = motor.DmMark,
FOutSpeedDisplay = motor.DmMark + "_Speed_" + Input,
FType = nType,
Tag = motor,
};
if (motor.DmType == 1)
{
float nRpm2Hz = Input / 60;
float n2LF = motor.DmLf * 2;
float nSlip = n2LF / motor.DmPoles - nRpm2Hz;
float nPPF = nSlip * motor.DmPoles;
featureItem["LF"] = motor.DmLf;
featureItem["Poles"] = motor.DmPoles;
featureItem["RS"] = Input / 60f;
featureItem["Bars"] = motor.DmBars;
featureItem["Slots"] = motor.DmSlots;
featureItem["PPF"] = nPPF;
featureItem["RBPF"] = motor.DmBars * nRpm2Hz;
featureItem["WSPF"] = motor.DmSlots * nRpm2Hz;
featureItem["2xLF"] = n2LF;
featureItem["Slip"] = nSlip;
}
else
{
featureItem["LF"] = motor.DmLf;
featureItem["RS"] = Input / 60f;
featureItem["Bar"] = motor.DmBars;
featureItem["Brush"] = motor.DmBrush;
featureItem["SCR"] = motor.DmScr;
}
#endregion
break;
case 2:
#region 齿轮
DirverGear gear = element as DirverGear;
float outSpeed = Input * gear.MNum1 / gear.MNum2;
featureItem = new FeatureItem()
{
FOutSpeed = outSpeed,
FInSpeed = Input,
FKey = gear.MId,
FName = gear.MName,
FMark = gear.MMark,
FOutSpeedDisplay = gear.MMark + "_Speed_" + outSpeed,
FType = 2,
Tag = gear,
};
featureItem["Shaft1"] = Input;
featureItem["Shaft2"] = outSpeed;
featureItem["Z1"] = gear.MNum1;
featureItem["Z2"] = gear.MNum2;
featureItem["GM"] = Input * gear.MNum1 / 60;
#endregion
break;
case 3:
#region 风机
DirverFan fan = element as DirverFan;
featureItem = new FeatureItem()
{
FInSpeed = Input,
FOutSpeed = Input,
FKey = fan.FId,
FName = fan.FName,
FMark = fan.FMark,
FOutSpeedDisplay = fan.FMark + "_Speed_" + Input,
FType = 3,
Tag = fan,
};
//叶片比问题 BRF = 转子叶片x扩压器叶片xRS/最大公约数 具有旋转叶片和静止扩压叶片的离心机
float tempF = fan.FBlades * fan.FDiffuserVane * Input / GCD(fan.FBlades, fan.FDiffuserVane);
featureItem["BRF"] = tempF;
featureItem["BP"] = fan.FBlades;
featureItem["BPF"] = fan.FBlades * Input / 60;
featureItem["RS"] = Input / 60f;
#endregion
break;
case 4:
#region 泵
DirverPump pump = element as DirverPump;
featureItem = new FeatureItem()
{
FInSpeed = Input,
FOutSpeed = Input,
FKey = pump.PId,
FName = pump.PName,
FMark = pump.PMark,
FOutSpeedDisplay = pump.PMark + "_Speed_" + Input,
FType = nType,
Tag = pump,
};
featureItem["VP"] = pump.PVanes;
featureItem["VPF"] = pump.PVanes * Input / 60f;
featureItem["RS"] = Input / 60f;
#endregion
break;
case 5:
#region 皮带转动/风机
DirverBelt belt = element as DirverBelt;
featureItem = new FeatureItem()
{
FInSpeed = Input,
FOutSpeed = belt.BD1 * Input / belt.BD2,
FKey = belt.BId,
FName = belt.BName,
FMark = belt.BMark,
FOutSpeedDisplay = belt.BMark + "_Speed_" + (belt.BD1 * Input / belt.BD2),
FType = nType,
Tag = belt
};
featureItem["D1"] = belt.BD1;
featureItem["D2"] = belt.BD2;
featureItem["CD"] = belt.BCenterLength;
featureItem["BPF"] = (float)((Math.PI * belt.BD1 * Input) / (0.5 * Math.PI * (belt.BD2 - belt.BD1)
+ 2 * Math.Sqrt(Math.Pow(belt.BCenterLength, 2) + Math.Pow(0.5 * belt.BD2 - 0.5 * belt.BD1, 2))));
featureItem["RS"] = belt.BD1 * Input / belt.BD2 / 60f;
#endregion
break;
case 6:
#region 变速机构
DirverShifting shifting = element as DirverShifting;
featureItem = new FeatureItem()
{
FInSpeed = Input,
FOutSpeed = Input / shifting.DsRatio,
FKey = shifting.DsId,
FName = shifting.DsName,
FMark = shifting.DsMark,
FOutSpeedDisplay = shifting.DsMark + "_Speed_" + (Input / shifting.DsRatio),
FType = nType,
Tag = shifting,
};
#endregion
break;
case 7:
#region 线速度
DirverLinerspeed linerSpeed = element as DirverLinerspeed;
featureItem = new FeatureItem()
{
FInSpeed = Input,
FOutSpeed = (float)(linerSpeed.DlMps * 1000 * 60 / (Math.PI * linerSpeed.DlD)),
FKey = linerSpeed.DlId,
FName = linerSpeed.DlName,
FMark = linerSpeed.DlMark,
FOutSpeedDisplay = linerSpeed.DlMark + "_Speed_" + (float)(linerSpeed.DlMps * 1000 * 60 / (Math.PI * linerSpeed.DlD)),
FType = nType,
Tag = linerSpeed,
};
#endregion
break;
case 8:
#region 行星齿轮箱
#endregion
break;
case 9:
#region 转子/轴
DirverRoller roller = element as DirverRoller;
featureItem = new FeatureItem()
{
FInSpeed = Input,
FOutSpeed = Input,
FKey = roller.DrId,
FName = roller.DrName,
FMark = roller.DrMark,
FOutSpeedDisplay = roller.DrMark + "_Speed_" + Input,
FType = nType,
Tag = roller,
};
featureItem["RS"] = Input / 60f;
#endregion
break;
case 11:
#region 滚动轴承
DirverBearing bearing = element as DirverBearing;
featureItem = new FeatureItem()
{
FInSpeed = Input,
FOutSpeed = Input,
FKey = bearing.Id,
FName = bearing.Name,
FMark = bearing.Mark,
FOutSpeedDisplay = bearing.Mark + "_Speed_" + Input,
FType = nType,
Tag = bearing,
CalcFrequency = new Dictionary <string, float>()
};
featureItem["RS"] = Input / 60f;
featureItem["BPFI"] = bearing.InsideRing;
featureItem["BPFO"] = bearing.OuterRing;
featureItem["FTF"] = bearing.Retainer;
featureItem["BSF"] = bearing.Roller;
#endregion
break;
case 12:
#region 滑动轴承
DirverBearingSlide bearingSlide = element as DirverBearingSlide;
featureItem = new FeatureItem()
{
FInSpeed = Input,
FOutSpeed = Input,
FKey = bearingSlide.BsId,
FName = bearingSlide.BsName,
FMark = bearingSlide.BsMark,
FOutSpeedDisplay = bearingSlide.BsMark + "_Speed_" + Input,
FType = nType,
Tag = bearingSlide,
};
featureItem["RS"] = Input / 60f;
#endregion
break;
case 13:
DirverFluidcoupling fluidCoupling = element as DirverFluidcoupling;
featureItem = new FeatureItem()
{
FInSpeed = Input,
FOutSpeed = Input * fluidCoupling.FcRange3,
FKey = fluidCoupling.FcId,
FName = fluidCoupling.FcName,
FMark = fluidCoupling.FcMark,
FOutSpeedDisplay = fluidCoupling.FcMark + "_Speed_" + (Input * fluidCoupling.FcRange3),
FType = nType,
Tag = fluidCoupling,
CalcFrequency = new Dictionary <string, float>()
};
featureItem["RS"] = Input / 60f;
break;
}
return(featureItem);
}
private static void GetAllInterfaces(List <string> interfaces, IList <FeatureItem> allFeatures, FeatureItem currentFeature, bool deep)
{
var interfacesFromFeature = currentFeature.FeatureDescriptor.ExportedTypes
.SelectMany(x => x.GetInterfaces())
.Where(x => typeof(IFeature).IsAssignableFrom(x) && x != typeof(IFeature))
.Select(x => x.Name);
interfaces.AddRange(interfacesFromFeature);
var dependencies = currentFeature.FeatureDescriptor.Dependencies.ToList();
if (deep && dependencies.Any())
{
dependencies.ForEach(x =>
GetAllInterfaces(interfaces, allFeatures,
allFeatures.SingleOrDefault(y => y.FeatureDescriptor.Name.Equals(x, StringComparison.OrdinalIgnoreCase)), true));
}
}
public void TestFeatureItem()
{
ISequence seq;
ISequence featureSeq = null;
GenBankParser parser = new GenBankParser();
string _genBankDataPath = @"TestUtils\GenBank";
seq = parser.ParseOne(_genBankDataPath + @"\BK000016-tpa.gbk");
GenBankMetadata metadata = seq.Metadata["GenBank"] as GenBankMetadata;
#region Test GetSubSequence Method
featureSeq = metadata.Features.All[0].GetSubSequence(seq);
int start = metadata.Features.All[0].Location.Start - 1;
int end = metadata.Features.All[0].Location.End - start;
Assert.AreEqual(featureSeq.ToString(), seq.Range(start, end).ToString());
featureSeq = metadata.Features.All[1].GetSubSequence(seq);
start = metadata.Features.All[1].Location.Start - 1;
end = metadata.Features.All[1].Location.End - start;
Assert.AreEqual(featureSeq.ToString(), seq.Range(start, end).ToString());
seq = new Sequence(Alphabets.DNA, "ACGTAAAGGT");
Sequence refSeq = new Sequence(Alphabets.DNA, "AAAAATTTT");
LocationBuilder locbuilder = new LocationBuilder();
ILocation loc = locbuilder.GetLocation("join(complement(4..8),Ref1:5..7)");
Assert.AreEqual("join(complement(4..8),Ref1:5..7)", locbuilder.GetLocationString(loc));
FeatureItem fi = new FeatureItem("Feature1", loc);
Dictionary <string, ISequence> refSeqs = new Dictionary <string, ISequence>();
refSeqs.Add("Ref1", refSeq);
ISequence result = fi.GetSubSequence(seq, refSeqs);
Assert.AreEqual("ATTTCATT", result.ToString());
#endregion
#region Test GetSubFeatures Method
SequenceFeatures seqFeatures = new SequenceFeatures();
FeatureItem source = new FeatureItem("Source", "1..1509");
FeatureItem mRNA = new FeatureItem("mRNA", "join(10..567,789..1320)");
FeatureItem cds = new FeatureItem("CDS", "join(54..567,789..1254)");
FeatureItem exon1 = new FeatureItem("Exon", "10..567");
FeatureItem intron = new FeatureItem("Intron", "568..788");
FeatureItem exon2 = new FeatureItem("Exon", "789..1320");
seqFeatures.All.Add(source);
seqFeatures.All.Add(mRNA);
seqFeatures.All.Add(cds);
seqFeatures.All.Add(exon1);
seqFeatures.All.Add(intron);
seqFeatures.All.Add(exon2);
List <FeatureItem> subFeatures = source.GetSubFeatures(seqFeatures);
Assert.AreEqual(5, subFeatures.Count);
subFeatures = mRNA.GetSubFeatures(seqFeatures);
Assert.AreEqual(4, subFeatures.Count);
subFeatures = cds.GetSubFeatures(seqFeatures);
Assert.AreEqual(1, subFeatures.Count);
subFeatures = exon1.GetSubFeatures(seqFeatures);
Assert.AreEqual(0, subFeatures.Count);
subFeatures = intron.GetSubFeatures(seqFeatures);
Assert.AreEqual(0, subFeatures.Count);
subFeatures = exon2.GetSubFeatures(seqFeatures);
Assert.AreEqual(0, subFeatures.Count);
#endregion
}
/// <summary>
/// Add GenBank metadata
/// </summary>
/// <param name="metadata">GenBank Metadata</param>
/// <returns>GenBank Metadat</returns>
private static GenBankMetadata AddGenBankMetadata(GenBankMetadata metadata)
{
metadata.Accession = new GenBankAccession();
metadata.Accession.Primary = "PAccession";
metadata.Accession.Secondary.Add("SAccession1");
metadata.Accession.Secondary.Add("SAccession2");
metadata.BaseCount = "a 1 c 2";
metadata.Comments.Add("Comment1");
metadata.Comments.Add("Comment2");
metadata.Contig = "Contig Info";
metadata.DBLink = new CrossReferenceLink();
metadata.DBLink.Type = CrossReferenceType.Project;
metadata.DBLink.Numbers.Add("100");
metadata.DBLink.Numbers.Add("200");
metadata.DBSource = "DbSourceInfo";
metadata.Definition = "Defination info";
metadata.Features = new SequenceFeatures();
FeatureItem feature = new FeatureItem("feature1", "1");
List <string> qualifierValues = new List <string>();
qualifierValues.Add("qualifier1value1");
qualifierValues.Add("qualifier1value2");
feature.Qualifiers.Add("qualifier1", qualifierValues);
metadata.Features.All.Add(feature);
feature = new FeatureItem("feature2", "2");
qualifierValues = new List <string>();
qualifierValues.Add("qualifier2value1");
qualifierValues.Add("qualifier2value2");
feature.Qualifiers.Add("qualifier2", qualifierValues);
metadata.Features.All.Add(feature);
feature = new FeatureItem("feature2", "2");
qualifierValues = new List <string>();
qualifierValues.Add("qualifier2value1");
qualifierValues.Add("qualifier2value2");
feature.Qualifiers.Add("qualifier2", qualifierValues);
metadata.Features.All.Add(feature);
metadata.Keywords = "keywords data";
metadata.Locus = new GenBankLocusInfo();
metadata.Locus.Date = DateTime.Now;
metadata.Locus.DivisionCode = SequenceDivisionCode.CON;
metadata.Locus.MoleculeType = MoleculeType.DNA;
metadata.Locus.Name = "LocusName";
metadata.Locus.SequenceLength = 100;
metadata.Locus.SequenceType = "bp";
metadata.Locus.Strand = SequenceStrandType.Double;
metadata.Locus.StrandTopology = SequenceStrandTopology.Linear;
metadata.Origin = "origin info";
metadata.Primary = "Primary info";
metadata.Project = new ProjectIdentifier();
metadata.Project.Name = "Project1";
metadata.Project.Numbers.Add("101");
metadata.Project.Numbers.Add("201");
CitationReference reference = new CitationReference();
reference.Authors = "Authors";
reference.Consortiums = "Consortiums";
reference.Journal = "Journal";
reference.Location = "3";
reference.Medline = "Medline info";
reference.Number = 1;
reference.PubMed = "pubmid";
reference.Remarks = "remarks";
reference.Title = "Title of the book";
metadata.References.Add(reference);
reference = new CitationReference();
reference.Authors = "Authors";
reference.Consortiums = "Consortiums";
reference.Journal = "Journal";
reference.Location = "4";
reference.Medline = "Medline info";
reference.Number = 2;
reference.PubMed = "pubmid";
reference.Remarks = "remarks";
reference.Title = "Title of the book";
metadata.References.Add(reference);
metadata.Segment = new SequenceSegment();
metadata.Segment.Count = 2;
metadata.Segment.Current = 1;
metadata.Source = new SequenceSource();
metadata.Source.CommonName = "ABC Xyz";
metadata.Source.Organism.Genus = "ABC";
metadata.Source.Organism.Species = "Xyz";
metadata.Source.Organism.ClassLevels = "123 123";
metadata.Version = new GenBankVersion();
metadata.Version.Accession = "PAccession";
metadata.Version.Version = "1";
metadata.Version.GINumber = "12345";
return(metadata);
}
// Setup
void Given_the_Step_Definition(string ExistingStepDefinitions)
{
Item = Create.TestObjectFor <FeatureItem>();
Given.That(Item).ContainsStepDefinitions.Is(true);
Given.That(Item).ExistingStepDefinitions.Are(ExistingStepDefinitions);
}
public static string GetTrnaAminoacid(FeatureItem item)
{
return(GetTrnaAminoacid(item.Name));
}
private Feature ParseFeature(string FeatureName, string Content, FeatureItem FeatureItem)
{
Feature = new Feature
{
FileName = FeatureName,
Content = Content.TrimLines(),
};
if (IsNotAValidFeature) return InvalidFeature;
Feature.Namespace = FeatureItem.DefaultNamespace;
Feature.Name = Name;
Feature.DeclaredStepDefinitions = DeclaredStepDefinitions;
// Hack Tech Debt
Feature.Content = Content;
Feature.Scenarios = ScenarioTokenizer.ScenariosFrom(Content);
Feature.Steps.ForEach(Step => Step.Feature = Feature);
return Feature;
}
public void GenBankMetadataClone()
{
LocationBuilder locBuilder = new LocationBuilder();
GenBankMetadata metadata = new GenBankMetadata();
metadata.Accession = new GenBankAccession();
metadata.Accession.Primary = "PAccession";
metadata.Accession.Secondary.Add("SAccession1");
metadata.Accession.Secondary.Add("SAccession2");
metadata.BaseCount = "a 1 c 2";
metadata.Comments.Add("Comment1");
metadata.Comments.Add("Comment2");
metadata.Contig = "Contig Info";
metadata.DBLink = new CrossReferenceLink();
metadata.DBLink.Type = CrossReferenceType.Project;
metadata.DBLink.Numbers.Add("100");
metadata.DBLink.Numbers.Add("200");
metadata.DBSource = "DbSourceInfo";
metadata.Definition = "Defination info";
metadata.Features = new SequenceFeatures();
FeatureItem feature = new FeatureItem("feature1", "1");
List <string> qualifierValues = new List <string>();
qualifierValues.Add("qualifier1value1");
qualifierValues.Add("qualifier1value2");
feature.Qualifiers.Add("qualifier1", qualifierValues);
metadata.Features.All.Add(feature);
feature = new FeatureItem("feature2", "2");
qualifierValues = new List <string>();
qualifierValues.Add("qualifier2value1");
qualifierValues.Add("qualifier2value2");
feature.Qualifiers.Add("qualifier2", qualifierValues);
metadata.Features.All.Add(feature);
feature = new FeatureItem("feature2", "2");
qualifierValues = new List <string>();
qualifierValues.Add("qualifier2value1");
qualifierValues.Add("qualifier2value2");
feature.Qualifiers.Add("qualifier2", qualifierValues);
metadata.Features.All.Add(feature);
metadata.Keywords = "keywords data";
metadata.Locus = new GenBankLocusInfo();
metadata.Locus.Date = DateTime.Now;
metadata.Locus.DivisionCode = SequenceDivisionCode.CON;
metadata.Locus.MoleculeType = MoleculeType.DNA;
metadata.Locus.Name = "LocusName";
metadata.Locus.SequenceLength = 100;
metadata.Locus.SequenceType = "bp";
metadata.Locus.Strand = SequenceStrandType.Double;
metadata.Locus.StrandTopology = SequenceStrandTopology.Linear;
metadata.Origin = "origin info";
metadata.Primary = "Primary info";
metadata.Project = new ProjectIdentifier();
metadata.Project.Name = "Project1";
metadata.Project.Numbers.Add("101");
metadata.Project.Numbers.Add("201");
CitationReference reference = new CitationReference();
reference.Authors = "Authors";
reference.Consortiums = "Consortiums";
reference.Journal = "Journal";
reference.Location = "3";
reference.Medline = "Medline info";
reference.Number = 1;
reference.PubMed = "pubmid";
reference.Remarks = "remarks";
reference.Title = "Title of the book";
metadata.References.Add(reference);
reference = new CitationReference();
reference.Authors = "Authors";
reference.Consortiums = "Consortiums";
reference.Journal = "Journal";
reference.Location = "4";
reference.Medline = "Medline info";
reference.Number = 2;
reference.PubMed = "pubmid";
reference.Remarks = "remarks";
reference.Title = "Title of the book";
metadata.References.Add(reference);
metadata.Segment = new SequenceSegment();
metadata.Segment.Count = 2;
metadata.Segment.Current = 1;
metadata.Source = new SequenceSource();
metadata.Source.CommonName = "ABC Xyz";
metadata.Source.Organism.Genus = "ABC";
metadata.Source.Organism.Species = "Xyz";
metadata.Source.Organism.ClassLevels = "123 123";
metadata.Version = new GenBankVersion();
metadata.Version.Accession = "PAccession";
metadata.Version.Version = "1";
metadata.Version.GINumber = "12345";
GenBankMetadata clonemetadta = metadata.Clone();
Assert.AreEqual(clonemetadta.Accession.Primary, metadata.Accession.Primary);
for (int i = 0; i < clonemetadta.Accession.Secondary.Count; i++)
{
Assert.AreEqual(clonemetadta.Accession.Secondary[i], metadata.Accession.Secondary[i]);
}
Assert.AreEqual(clonemetadta.BaseCount, metadata.BaseCount);
for (int i = 0; i < clonemetadta.Comments.Count; i++)
{
Assert.AreEqual(clonemetadta.Comments[i], metadata.Comments[i]);
}
Assert.AreEqual(clonemetadta.Contig, metadata.Contig);
Assert.AreEqual(clonemetadta.DBLink.Type, metadata.DBLink.Type);
for (int i = 0; i < clonemetadta.DBLink.Numbers.Count; i++)
{
Assert.AreEqual(clonemetadta.DBLink.Numbers[i], metadata.DBLink.Numbers[i]);
}
Assert.AreEqual(clonemetadta.DBSource, metadata.DBSource);
Assert.AreEqual(clonemetadta.Definition, metadata.Definition);
for (int i = 0; i < clonemetadta.Features.All.Count; i++)
{
Assert.AreEqual(clonemetadta.Features.All[i].Key, metadata.Features.All[i].Key);
Assert.AreEqual(locBuilder.GetLocationString(clonemetadta.Features.All[i].Location), locBuilder.GetLocationString(metadata.Features.All[i].Location));
foreach (KeyValuePair <string, List <string> > kvp in clonemetadta.Features.All[i].Qualifiers)
{
if (metadata.Features.All[i].Qualifiers.ContainsKey(kvp.Key))
{
if (kvp.Value == null)
{
Assert.IsNull(metadata.Features.All[i].Qualifiers[kvp.Key]);
}
else
{
for (int j = 0; j < kvp.Value.Count; j++)
{
Assert.AreEqual(kvp.Value[j], metadata.Features.All[i].Qualifiers[kvp.Key][j]);
}
}
}
else
{
Assert.Fail();
}
}
}
Assert.AreEqual(clonemetadta.Keywords, metadata.Keywords);
Assert.AreEqual(clonemetadta.Locus.Date, metadata.Locus.Date);
Assert.AreEqual(clonemetadta.Locus.DivisionCode, metadata.Locus.DivisionCode);
Assert.AreEqual(clonemetadta.Locus.MoleculeType, metadata.Locus.MoleculeType);
Assert.AreEqual(clonemetadta.Locus.Name, metadata.Locus.Name);
Assert.AreEqual(clonemetadta.Locus.SequenceLength, metadata.Locus.SequenceLength);
Assert.AreEqual(clonemetadta.Locus.SequenceType, metadata.Locus.SequenceType);
Assert.AreEqual(clonemetadta.Locus.Strand, metadata.Locus.Strand);
Assert.AreEqual(clonemetadta.Locus.StrandTopology, metadata.Locus.StrandTopology);
Assert.AreEqual(clonemetadta.Origin, clonemetadta.Origin);
Assert.AreEqual(clonemetadta.Primary, metadata.Primary);
Assert.AreEqual(clonemetadta.Project.Name, metadata.Project.Name);
for (int i = 0; i < clonemetadta.Project.Numbers.Count; i++)
{
Assert.AreEqual(clonemetadta.Project.Numbers[i], metadata.Project.Numbers[i]);
}
for (int i = 0; i < clonemetadta.References.Count; i++)
{
Assert.AreEqual(clonemetadta.References[i].Authors, metadata.References[i].Authors);
Assert.AreEqual(clonemetadta.References[i].Consortiums, metadata.References[i].Consortiums);
Assert.AreEqual(clonemetadta.References[i].Journal, metadata.References[i].Journal);
Assert.AreEqual(clonemetadta.References[i].Location, metadata.References[i].Location);
Assert.AreEqual(clonemetadta.References[i].Medline, metadata.References[i].Medline);
Assert.AreEqual(clonemetadta.References[i].Number, metadata.References[i].Number);
Assert.AreEqual(clonemetadta.References[i].PubMed, metadata.References[i].PubMed);
Assert.AreEqual(clonemetadta.References[i].Remarks, metadata.References[i].Remarks);
Assert.AreEqual(clonemetadta.References[i].Title, metadata.References[i].Title);
}
Assert.AreEqual(clonemetadta.Segment.Current, metadata.Segment.Current);
Assert.AreEqual(clonemetadta.Segment.Count, metadata.Segment.Count);
Assert.AreEqual(clonemetadta.Source.CommonName, metadata.Source.CommonName);
Assert.AreEqual(clonemetadta.Source.Organism.ClassLevels, metadata.Source.Organism.ClassLevels);
Assert.AreEqual(clonemetadta.Source.Organism.Genus, metadata.Source.Organism.Genus);
Assert.AreEqual(clonemetadta.Source.Organism.Species, metadata.Source.Organism.Species);
Assert.AreEqual(clonemetadta.Version.Accession, metadata.Version.Accession);
Assert.AreEqual(clonemetadta.Version.CompoundAccession, metadata.Version.CompoundAccession);
Assert.AreEqual(clonemetadta.Version.GINumber, metadata.Version.GINumber);
Assert.AreEqual(clonemetadta.Version.Version, metadata.Version.Version);
}
public Feature FeatureFrom(string FeatureText, FeatureItem FeatureItem)
{
return(ParseFeature(null, FeatureText, FeatureItem));
}
public static int CreateItems(UIParameters Up, ISequence rec, int itemId, int seqPos, Collection collection)
{
string queryName = rec.DisplayID.ToString().Split(' ')[0];
// BLAST reports are saved in individual files by query and
// numbered in the same order as they appear in the input FASTA file.
string blastFile = Up.ProjectDir + "\\xml\\" + seqPos + ".xml";
if (!File.Exists(blastFile))
{
throw new Exception("File does not exist.");
}
BlastXmlParser blastParser = new BlastXmlParser();
IList <BlastResult> blastResults = blastParser.Parse(blastFile);
GenBankParser gbParser = new GenBankParser();
int[] annotatedIndex = GetBestAnnotatedIndex(Up, seqPos);
// iterate through the BLAST results.
foreach (BlastResult blastResult in blastResults)
{
foreach (BlastSearchRecord record in blastResult.Records)
{
int hitsProcessed = 0;
// If there are not hits in the BLAST result ...
int rank = 0;
if (record.Hits.Count() > 0)
{
// For each hit
for (int i = 0; i < record.Hits.Count(); i++)
{
Hit blastHit = record.Hits[i];
// For each HSP
for (int j = 0; j < blastHit.Hsps.Count(); j++)
{
Hsp blastHsp = blastHit.Hsps[j];
double percentId = (blastHsp.IdentitiesCount / (double)blastHsp.AlignmentLength) * 100;
double queryCoverage = ((double)(blastHsp.QueryEnd - blastHsp.QueryStart + 1) / record.IterationQueryLength) * 100;
string txt = String.Format("{0} {1} {2} {3} {4} {5} {6} {7}", percentId, Up.BlastMinPercentIdentity,
Up.BlastMaxEvalue, blastHsp.EValue, queryCoverage, Up.BlastMinPercentQueryCoverage,
hitsProcessed, Up.BlastMaxNumHits);
// if HSP passes user-defined thresholds
if ((percentId >= Up.BlastMinPercentIdentity) &&
(Up.BlastMaxEvalue >= blastHsp.EValue) &&
(queryCoverage >= Up.BlastMinPercentQueryCoverage) &&
(hitsProcessed < Up.BlastMaxNumHits))
{
rank += 1;
string nextScore = "no";
if ((i + 1) < record.Hits.Count())
{
if (blastHsp.Score > record.Hits[i + 1].Hsps[0].Score)
{
nextScore = "less than";
}
else
{
nextScore = "equal";
}
}
else
{
nextScore = "non existent";
}
// parse GI numner from hit
long gi = Convert.ToInt64(blastHit.Id.Split('|')[1]);
GenBankItem gitem = new GenBankItem(gi, blastHsp.HitStart, blastHsp.HitEnd);
string gbFile = Up.ProjectDir + "\\gb\\" + gitem.Id.ToString();
gbFile += "_" + gitem.HitStart.ToString();
gbFile += "_" + gitem.HitEnd.ToString();
gbFile += ".gb";
// init item
string img = "#" + itemId.ToString();
Item item = new Item(itemId, img);
string[] headerTokens = parseFastaHeader(rec.DisplayID.ToString());
item.Name = headerTokens[0];
item.Description = headerTokens[1];
// write pairwise alignment
writePairwiseAlignment(Up, blastHit, j, itemId);
// try to parse the GB record associated with the hit and set facet values to data from BLAST/GB record
try
{
Console.WriteLine("GB OK: " + record.Hits[0].Id + " " + i.ToString() + " " + j.ToString());
ISequence gbRecord = gbParser.ParseOne(gbFile);
item.Href = GetNCBIUrl(Up.BlastProgram) + GetGenBankIdentifier(gbRecord);
GenBankMetadata gbMeta = (GenBankMetadata)gbRecord.Metadata["GenBank"];
CodingSequence bestCds = null;
IList <FeatureItem> features = gbMeta.Features.All;
FeatureItem bestItem = getBestFeatureItem(features);
if (gbMeta.Features.CodingSequences.Count > 0)
{
bestCds = gbMeta.Features.CodingSequences[0];
}
for (int k = 1; k < gbMeta.Features.CodingSequences.Count; k++)
{
CodingSequence cds = gbMeta.Features.CodingSequences[k];
//int bestSize = Math.Abs(bestCds.Location.End - bestCds.Location.Start);
int bestSize = Math.Abs(bestItem.Location.End - bestItem.Location.Start);
int cdsSize = Math.Abs(cds.Location.End - cds.Location.Start);
if (cdsSize > bestSize)
{
bestCds = cds;
}
}
foreach (FacetCategory f in Up.FacetCategories)
{
Facet facet = new Facet();
switch (f.Name)
{
case "InputOrder":
facet = new Facet(f.Name, f.Type, seqPos);
break;
case "QuerySequence":
facet = new Facet(f.Name, f.Type, rec.ToString());
break;
case "NextScore":
facet = new Facet(f.Name, f.Type, nextScore);
break;
case "Annotated":
string value = "na";
if ((annotatedIndex[0] == i) && (annotatedIndex[1] == j))
{
value = "top_annotated";
}
else
{
if ((i == 0) && (j == 0) && (annotatedIndex[0] == -1) && (annotatedIndex[1] == -1))
{
value = "top_unannotated";
}
else
{
if (bestItem != null)
{
value = "annotated";
}
else
{
value = "unannotated";
}
}
}
facet = new Facet(f.Name, f.Type, value);
break;
default:
//facet = CreateFacet(f.Name, f.Type, record, i, j, gbRecord, item, GetNCBIUrl(Up.BlastProgram), bestCds, rank);
facet = CreateFacet(f.Name, f.Type, record, i, j, gbRecord, item, GetNCBIUrl(Up.BlastProgram), bestItem, rank);
break;
}
/*
* if (f.Name == "InputOrder")
* {
* facet = new Facet(f.Name, f.Type, seqPos);
* }
*
* else
* {
* facet = CreateFacet(f.Name, f.Type, record, i, j, gbRecord, item);
* }
*/
item.Facets.Add(facet);
}
}
//catch (System.NullReferenceException e) // if parsing failed init the item w/ default values (similar to 'no hit' above)
catch
{
Console.WriteLine("GB ERROR: " + record.Hits[0].Id + " " + i.ToString() + " " + j.ToString());
item.Href = "#";
foreach (FacetCategory f in Up.FacetCategories)
{
Facet facet = new Facet();
switch (f.Name)
{
case ("InputOrder"):
facet = new Facet(f.Name, f.Type, seqPos);
break;
case "QuerySequence":
facet = new Facet(f.Name, f.Type, rec.ToString());
break;
case ("NextScore"):
facet = new Facet(f.Name, f.Type, "no");
break;
case "Annotated":
string value = "na";
if ((annotatedIndex[0] == i) && (annotatedIndex[1] == j))
{
value = "top_annotated";
}
else
{
if ((i == 0) && (j == 0) && (annotatedIndex[0] == -1) && (annotatedIndex[1] == -1))
{
value = "top_unannotated";
}
else
{
value = "unannotated";
}
}
facet = new Facet(f.Name, f.Type, value);
break;
default:
facet = CreateGBErrorFacet(f.Name, f.Type, record, i, j, item, GetNCBIUrl(Up.BlastProgram), rank);
break;
}
item.Facets.Add(facet);
}
//throw (e);
}
// Add item to collection, increment to next item,
collection.Items.Add(item);
hitsProcessed += 1;
itemId += 1;
}
}
}
}
if ((record.Hits.Count()) == 0 || (hitsProcessed == 0))
{
// Init Pivot item
string img = "#" + itemId.ToString();
Item item = new Item(itemId, img);
item.Href = "#";
string[] headerTokens = parseFastaHeader(rec.DisplayID.ToString());
item.Name = headerTokens[0];
item.Description = headerTokens[1];
// Write pairwise alignment to file.
writePairwiseAlignment(Up, itemId);
// Set facet values for each facet category to default values
foreach (FacetCategory f in Up.FacetCategories)
{
Facet facet = new Facet();
switch (f.Name)
{
case ("InputOrder"):
facet = new Facet(f.Name, f.Type, seqPos);
break;
case ("QuerySequence"):
facet = new Facet(f.Name, f.Type, rec.ToString());
break;
default:
facet = CreateFacet(f.Name, f.Type, record, item, 0);
break;
}
item.Facets.Add(facet);
}
// Add item to collection, increment to next item, skip remaining code
collection.Items.Add(item);
itemId += 1;
hitsProcessed += 1;
}
}
}
return(itemId);
}
//public static string GetQualifierStringFromCDS(CodingSequence cds, string qualifierKey)
public static string GetQualifierStringFromCDS(FeatureItem cds, string qualifierKey)
{
foreach (KeyValuePair<string, List<string>> q in cds.Qualifiers)
{
if (q.Key == qualifierKey)
{
return q.Value[0].Trim('"');
}
}
return "N/A";
}
public Feature FeatureFrom(FeatureFile FeatureFile, FeatureItem FeatureItem)
{
return ParseFeature(FeatureFile.Name, FeatureFile.Content, FeatureItem);
}
public Feature FeatureFrom(string FeatureText, FeatureItem FeatureItem)
{
return ParseFeature(null, FeatureText, FeatureItem);
}
// Setup
void Given_the_Step_Definition(string ExistingStepDefinitions)
{
Item = Create.TestObjectFor<FeatureItem>();
Given.That(Item).ContainsStepDefinitions.Is(true);
Given.That(Item).ExistingStepDefinitions.Are(ExistingStepDefinitions);
}
public static string GetTrnaAnticodon(FeatureItem item)
{
return(GetTrnaAnticodon(item.Name));
}
