/// <summary>
/// Returns a LibraryRankedSpectrumInfo
/// </summary>
/// <param name="info">The spectrum to be ranked</param>
/// <param name="labelType">The IsotopeLabelType for the peptide in the library. This might be different from the
/// LabelType on the GroupDocNode.</param>
/// <param name="groupDocNode">The Transition Group from the user's document</param>
/// <param name="settings"></param>
/// <param name="lookupSequence"></param>
/// <param name="lookupMods"></param>
/// <param name="charges">The set of charges that the user is choosing to show in the spectrum viewer.</param>
/// <param name="types">The set of ion types to be displayed</param>
/// <param name="rankCharges">The set of charges that are enabled in the document's Transition Settings</param>
/// <param name="rankTypes">The set of ion types in the user's transition settings</param>
/// <param name="score">the score to assign to the spectrum. If it is null, then the spectrum gets the score from transition group's LibInfo</param>
/// <param name="useFilter">true if this list is being generated in order to show the filtered list of potential transitions</param>
/// <param name="matchAll">true if peaks matched peaks should be given a list of all of the ion types that they match, instead
/// of only being annotated with the first matching one</param>
/// <param name="minPeaks">The minimum number of peaks to match, or -1 to match as many as possible</param>
/// <returns></returns>
public static LibraryRankedSpectrumInfo RankSpectrum(SpectrumPeaksInfo info,
IsotopeLabelType labelType,
TransitionGroupDocNode groupDocNode, SrmSettings settings,
Target lookupSequence, ExplicitMods lookupMods,
IEnumerable <Adduct> charges, IEnumerable <IonType> types,
IEnumerable <Adduct> rankCharges, IEnumerable <IonType> rankTypes,
double?score, bool useFilter, bool matchAll, int minPeaks)
{
var targetInfo = new TargetInfo(labelType, groupDocNode, lookupSequence, lookupMods);
var fragmentFilter = new FragmentFilter(settings.TransitionSettings, rankCharges, rankTypes).ChangeMatchAll(matchAll);
if (!useFilter)
{
bool isProteomic = groupDocNode.TransitionGroup.IsProteomic;
fragmentFilter = fragmentFilter.ChangeUseFilter(false);
fragmentFilter = fragmentFilter
.ChangeAdductsToDisplay(charges ?? GetRanked(fragmentFilter.RankedAdducts,
isProteomic
? Transition.DEFAULT_PEPTIDE_CHARGES
: Transition.DEFAULT_MOLECULE_CHARGES));
fragmentFilter = fragmentFilter.ChangeIonTypesToDisplay(
types ?? GetRanked(fragmentFilter.RankedIonTypes,
isProteomic ? Transition.PEPTIDE_ION_TYPES : Transition.MOLECULE_ION_TYPES));
fragmentFilter = fragmentFilter.ChangeMatchAll(true);
}
else
{
if (null != charges)
{
fragmentFilter = fragmentFilter.ChangeAdductsToDisplay(charges);
}
if (null != types)
{
fragmentFilter = fragmentFilter.ChangeIonTypesToDisplay(types);
}
}
bool limitRanks =
groupDocNode.IsCustomIon && // For small molecules, cap the number of ranked ions displayed if we don't have any peak metadata
groupDocNode.Transitions.Any(t => string.IsNullOrEmpty(t.FragmentIonName));
if (limitRanks)
{
fragmentFilter = fragmentFilter.ChangeRankLimit(settings.TransitionSettings.Libraries.IonCount);
}
// If no library filtering will happen, return all rankings for view in the UI
if (!useFilter || fragmentFilter.LibraryPick == TransitionLibraryPick.none)
{
if (fragmentFilter.LibraryPick == TransitionLibraryPick.none)
{
fragmentFilter = fragmentFilter.ChangeLibraryPick(TransitionLibraryPick.all);
}
fragmentFilter = fragmentFilter.ChangeFragmentMatchCount(null);
}
var spectrumRanker = new SpectrumRanker(targetInfo, settings, fragmentFilter);
return(spectrumRanker.RankSpectrum(info, minPeaks, score));
}
private void Render(DisplayObject obj, Matrix2D matrix = null, float alpha = 1.0f)
{
Painter painter = SparrowSharp.Painter;
RenderState state = painter.State;
bool wasCacheEnabled = painter.CacheEnabled;
FragmentFilter filter = obj.Filter;
DisplayObject mask = obj.Mask;
painter.CacheEnabled = false;
painter.PushState();
state.Alpha = obj.Alpha * alpha;
state.SetModelviewMatricesToIdentity();
state.BlendMode = obj.BlendMode == BlendMode.AUTO ?
BlendMode.NORMAL : obj.BlendMode;
if (matrix != null)
{
state.TransformModelviewMatrix(matrix);
}
else
{
state.TransformModelviewMatrix(obj.TransformationMatrix);
}
// OpenGL calculates y coordinates from the bottom, invert them here
state.ModelviewMatrix.Scale(1, -1);
state.ModelviewMatrix.Translate(0, Height);
if (mask != null)
{
painter.DrawMask(mask);
}
if (filter != null)
{
filter.Render(painter);
}
else
{
obj.Render(painter);
}
if (mask != null)
{
painter.EraseMask(mask);
}
painter.PopState();
painter.CacheEnabled = wasCacheEnabled;
}
public void render3d(Project project, SceneManager sceneMgr)
{
SharpMap.Map myMap = new SharpMap.Map();
foreach (BuildLayer layer in project.getLayers())
{
Source source = layer.getSource();
BoundingBox envelope = new BoundingBox(-1000.0, -1000.0, 1000.0, 1000.0);//TODO
FeatureDataSet ds = new FeatureDataSet();
source.DataSource.Open();
source.DataSource.ExecuteIntersectionQuery(envelope, ds);
source.DataSource.Close();
FeatureDataTable features = (FeatureDataTable)ds.Tables[0];
//El codigo del PFC
//**********************************************************************************************************
//Show map
//Filters
FilterGraph graph = project.getFilterGraph(source.getName());
if (graph != null)
{
graph.Successors();
FilterEnv env = new FilterEnv(sceneMgr, source.getName());
FeatureList list = Feature.DataTableToList(features);
if (graph.getFilter(1) is FeatureFilter)
{
FeatureFilter filter = (FeatureFilter)graph.getFilter(1);
FeatureList l = filter.process(list, env);
}
else if (graph.getFilter(1) is FragmentFilter)
{
FragmentFilter filter = (FragmentFilter)graph.getFilter(1);
FragmentList l = filter.process(list, env);
}
}
//**********************************************************************************************************
}
}
protected bool IsStateChange(uint texture,
TextureSmoothing smoothing, string blendMode, FragmentFilter filter,
bool premultiplyAlpha, int numParticles)
{
if (_mNumParticles == 0)
{
return(false);
}
if (_mNumParticles + numParticles > MaxPossibleParticles)
{
return(true);
}
if (_mTexture != null && texture != 0)
{
return(_mTexture.Base != texture || TexSmoothing != smoothing || BlendMode != blendMode ||
_mFilter != filter || PremultiplyAlpha != premultiplyAlpha);
}
return(true);
}
public FragmentFilterState(FragmentFilter _filter)
{
filter = _filter;
}
public SpectrumRanker(TargetInfo targetInfo, SrmSettings settings,
FragmentFilter fragmentFilter)
{
TargetInfoObj = targetInfo;
FragmentFilterObj = fragmentFilter;
var groupDocNode = TargetInfoObj.TransitionGroupDocNode;
TransitionGroup group = groupDocNode.TransitionGroup;
bool isProteomic = group.IsProteomic;
bool limitRanks =
groupDocNode.IsCustomIon && // For small molecules, cap the number of ranked ions displayed if we don't have any peak metadata
groupDocNode.Transitions.Any(t => string.IsNullOrEmpty(t.FragmentIonName));
RankLimit = limitRanks ? settings.TransitionSettings.Libraries.IonCount : (int?)null;
// Get necessary mass calculators and masses
var labelType = targetInfo.SpectrumLabelType;
var lookupMods = targetInfo.LookupMods;
var calcMatchPre = settings.GetPrecursorCalc(labelType, lookupMods);
var calcMatch = isProteomic ? settings.GetFragmentCalc(labelType, lookupMods) : settings.GetDefaultFragmentCalc();
var calcPredict = isProteomic ? settings.GetFragmentCalc(group.LabelType, lookupMods) : calcMatch;
MoleculeMasses moleculeMasses;
if (null != lookupMods && lookupMods.HasCrosslinks)
{
moleculeMasses = GetCrosslinkMasses(settings);
}
else
{
if (isProteomic && Sequence.IsProteomic)
{
moleculeMasses = new MoleculeMasses(
SequenceMassCalc.GetMZ(calcMatchPre.GetPrecursorMass(Sequence), PrecursorAdduct),
new IonMasses(calcMatch.GetPrecursorFragmentMass(Sequence),
calcMatch.GetFragmentIonMasses(Sequence)));
}
else if (!isProteomic && !Sequence.IsProteomic)
{
string isotopicFormula;
var knownFragments = new List <MatchedFragmentIon>();
foreach (var tran in groupDocNode.Transitions)
{
if (tran.Transition.IsNonPrecursorNonReporterCustomIon())
{
knownFragments.Add(new MatchedFragmentIon(IonType.custom, knownFragments.Count + 1,
tran.Transition.Adduct,
tran.GetFragmentIonName(CultureInfo.CurrentCulture,
settings.TransitionSettings.Libraries.IonMatchTolerance),
null,
tran.Mz));
}
}
var ionMasses =
new IonMasses(calcMatch.GetPrecursorFragmentMass(Sequence), IonTable <TypedMass> .EMPTY)
.ChangeKnownFragments(knownFragments);
moleculeMasses =
new MoleculeMasses(
SequenceMassCalc.GetMZ(
calcMatchPre.GetPrecursorMass(Sequence.Molecule, null, PrecursorAdduct,
out isotopicFormula), PrecursorAdduct), ionMasses);
}
else
{
moleculeMasses = new MoleculeMasses(0.0,
new IonMasses(TypedMass.ZERO_MONO_MASSH, IonTable <TypedMass> .EMPTY));
}
if (!ReferenceEquals(calcPredict, calcMatch))
{
var ionTable = moleculeMasses.MatchIonMasses.FragmentMasses;
if (Sequence.IsProteomic
) // CONSIDER - eventually we may be able to predict fragments for small molecules?
{
ionTable = calcPredict.GetFragmentIonMasses(Sequence);
}
moleculeMasses =
moleculeMasses.ChangePredictIonMasses(new IonMasses(
calcPredict.GetPrecursorFragmentMass(Sequence),
ionTable));
}
}
MoleculeMassesObj = moleculeMasses;
// Get values of interest from the settings.
TransitionSettings = settings.TransitionSettings;
// Get potential losses to all fragments in this peptide
PotentialLosses = TransitionGroup.CalcPotentialLosses(Sequence, settings.PeptideSettings.Modifications,
lookupMods, MassType);
}
public override void Render(Painter painter)
{
int numChildren = _children.Count;
uint frameId = painter.FrameId;
bool cacheEnabled = frameId != 0;
bool selfOrParentChanged = _lastParentOrSelfChangeFrameID == frameId;
for (int i = 0; i < numChildren; ++i)
{
DisplayObject child = _children[i];
if (child._hasVisibleArea)
{
if (selfOrParentChanged)
{
child._lastParentOrSelfChangeFrameID = frameId;
}
if (child._lastParentOrSelfChangeFrameID != frameId &&
child._lastChildChangeFrameID != frameId &&
child._tokenFrameID == frameId - 1 && cacheEnabled)
{
painter.PushState(SCacheToken);
painter.DrawFromCache(child._pushToken, child._popToken);
painter.PopState(child._popToken);
child._pushToken.CopyFrom(SCacheToken);
}
else
{
BatchToken pushToken = cacheEnabled ? child._pushToken : null;
BatchToken popToken = cacheEnabled ? child._popToken : null;
FragmentFilter filter = child._filter;
DisplayObject mask = child._mask;
painter.PushState(pushToken);
painter.SetStateTo(child.TransformationMatrix, child.Alpha, child.BlendMode);
if (mask != null)
{
painter.DrawMask(mask, child);
}
if (filter != null)
{
filter.Render(painter);
}
else
{
child.Render(painter);
}
if (mask != null)
{
painter.EraseMask(mask, child);
}
painter.PopState(popToken);
}
if (cacheEnabled)
{
child._tokenFrameID = frameId;
}
}
}
}
