/// <summary>
/// Validate BED Operations(Merge,Intersect)..
/// </summary>
/// <param name="nodeName">Xml Node name for different inputs.</param>
/// <param name="operationPam">Different Bed operations.</param>
/// <param name="overlappingBasePair">overlapping base pair</param>
/// <param name="IsParentSeqRangeRequired">Is Parent Sequence Range required?</param>
void ValidateBedOperations(string nodeName,
BedOperationsParameters operationPam,
bool overlappingBasePair, bool IsParentSeqRangeRequired)
{
// Get values from xml.
string expectedRangeIDs = utilityObj.xmlUtil.GetTextValue(
nodeName, Constants.IDNode);
string expectedStartIndex = utilityObj.xmlUtil.GetTextValue(
nodeName, Constants.StartNode);
string expectedEndIndex = utilityObj.xmlUtil.GetTextValue(
nodeName, Constants.EndNode);
string referenceFilePath = utilityObj.xmlUtil.GetTextValue(
nodeName, Constants.FilePathNode);
string queryFilePath = utilityObj.xmlUtil.GetTextValue(
nodeName, Constants.QueryFilePath);
string minimalOverlap = utilityObj.xmlUtil.GetTextValue(
nodeName, Constants.OverlapValue);
string rangeID = string.Empty;
bool result = false;
List <ISequenceRange> rangeList = null;
SequenceRangeGrouping operationResult = null;
// Parse a BED file.
BedParser parserObj = new BedParser();
SequenceRangeGrouping referenceGroup = parserObj.ParseRangeGrouping(referenceFilePath);
SequenceRangeGrouping queryGroup = parserObj.ParseRangeGrouping(queryFilePath);
IntersectOutputType intersectOutputType = IntersectOutputType.OverlappingIntervals;
if (overlappingBasePair)
{
intersectOutputType = IntersectOutputType.OverlappingPiecesOfIntervals;
}
SubtractOutputType subtractOutputType = SubtractOutputType.NonOverlappingPiecesOfIntervals;
if (overlappingBasePair)
{
subtractOutputType = SubtractOutputType.IntervalsWithNoOverlap;
}
switch (operationPam)
{
case BedOperationsParameters.Merge:
operationResult = referenceGroup.MergeOverlaps();
break;
case BedOperationsParameters.MergeWithPam:
operationResult = referenceGroup.MergeOverlaps(queryGroup,
0, IsParentSeqRangeRequired);
break;
case BedOperationsParameters.Intersect:
operationResult = referenceGroup.Intersect(queryGroup,
long.Parse(minimalOverlap, (IFormatProvider)null), intersectOutputType, IsParentSeqRangeRequired);
break;
case BedOperationsParameters.MergeQueryWithReference:
operationResult = queryGroup.MergeOverlaps(referenceGroup,
0, IsParentSeqRangeRequired);
break;
case BedOperationsParameters.Subtract:
operationResult = referenceGroup.Subtract(queryGroup,
long.Parse(minimalOverlap, (IFormatProvider)null), subtractOutputType, IsParentSeqRangeRequired);
break;
default:
break;
}
// Get a result SequenceGroup Id.
IEnumerable <string> groupId = operationResult.GroupIDs;
string[] expectedRangeIdsArray = expectedRangeIDs.Split(',');
string[] expectedStartIndexArray = expectedStartIndex.Split(',');
string[] expectedEndIndexArray = expectedEndIndex.Split(',');
int i = 0;
foreach (string grpID in groupId)
{
rangeID = grpID;
rangeList = operationResult.GetGroup(rangeID);
// Validate result sequence range.
foreach (ISequenceRange range in rangeList)
{
Assert.AreEqual(expectedRangeIdsArray[i], range.ID);
Assert.AreEqual(expectedStartIndexArray[i], range.Start.ToString((IFormatProvider)null));
Assert.AreEqual(expectedEndIndexArray[i], range.End.ToString((IFormatProvider)null));
i++;
}
}
// Validate ParentSeqRange.
result = ValidateParentSeqRange(operationResult, referenceGroup,
queryGroup, IsParentSeqRangeRequired);
Assert.IsTrue(result);
ApplicationLog.WriteLine(
"Bed Operations BVT: Successfully validated the BED SequenceID, Start and End Ranges");
}
/// <summary>
/// Returns overlapping sequence ranges from this and specified SequenceRangeGroup for each group in this grouping.
///
/// For instance if you had in group 'Chr1' the following ranges:
///
/// Ranges in this instance Ranges in the query
/// 0 to 10 20 to 40
/// 30 to 50 70 to 100
/// 60 to 80 400 to 800
/// 300 to 500 850 to 900
/// 600 to 700 900 to 1200
/// 800 to 1000
///
/// Result for minOverlap set to 1
/// 1. If outputType is OverlappingPiecesOfIntervals.
/// 30 to 40
/// 70 to 80
/// 400 to 500
/// 600 o 700
/// 850 to 900
/// 900 to 1000
/// 2. If outputType is OverlappingIntervals
/// 30 to 50
/// 60 to 80
/// 300 to 500
/// 600 to 700
/// 800 to 1000
///
/// Running this method creates all new ISequenceRange objects and adds them
/// to the newly created SequenceRangeGrouping returned here.
/// </summary>
/// <param name="query">Query grouping.</param>
/// <param name="minOverlap">Minmum length of bases pairs should be overlapped.
/// By default this will be set to 1.</param>
/// <param name="outputType">
/// Type of output required, OverlappingPiecesOfIntervals or OverlappingIntervals.
/// By default this will be set to OverlappingPiecesOfIntervals that is only the base pairs that overlaps with
/// query ranges will be returned.</param>
/// <param name="isParentSeqRangesRequired">If this flag is set to true then the sequence ranges from
/// which the new sequence range is created are added to the ParentSeqRanges property of the
/// new sequence ranges.</param>
/// <returns>The intersected result.</returns>
public SequenceRangeGrouping Intersect(SequenceRangeGrouping query, long minOverlap = 1, IntersectOutputType outputType = IntersectOutputType.OverlappingPiecesOfIntervals, bool isParentSeqRangesRequired = false)
{
if (query == null)
{
throw new ArgumentNullException("query");
}
SequenceRangeGrouping result = new SequenceRangeGrouping();
List<ISequenceRange> refSeqRanges = new List<ISequenceRange>();
List<ISequenceRange> querySeqRanges = new List<ISequenceRange>();
SequenceRange range = null;
// merge the query sequence ranges.
IList<ISequenceRange> queryList = null;
if (isParentSeqRangesRequired)
{
queryList = query.Flatten();
}
query = query.MergeOverlaps(0, isParentSeqRangesRequired);
foreach (string id in groups.Keys)
{
refSeqRanges.Clear();
querySeqRanges.Clear();
refSeqRanges.AddRange(groups[id]);
if (query.groups.ContainsKey(id))
{
querySeqRanges.AddRange(query.groups[id]);
querySeqRanges.Sort();
}
if (querySeqRanges.Count > 0)
{
foreach (ISequenceRange refRange in refSeqRanges)
{
IList<ISequenceRange> overlappingQueryRanges = GetOverlappingRenges(refRange, querySeqRanges, minOverlap);
if (overlappingQueryRanges == null || overlappingQueryRanges.Count == 0)
{
// If the minOverlap is lessthan or equal to zero and overlapping intervals are required.
// then add the ref seq to result.
if (minOverlap <= 0 && outputType == IntersectOutputType.OverlappingIntervals)
{
range = new SequenceRange(refRange.ID, refRange.Start, refRange.End);
CopyOfMetadata(range, refRange);
result.Add(range);
if (isParentSeqRangesRequired)
{
AddParent(range, refRange);
}
}
continue;
}
ISequenceRange previousOverlappingRange = null;
foreach (ISequenceRange queryRange in overlappingQueryRanges)
{
if (outputType == IntersectOutputType.OverlappingPiecesOfIntervals)
{
// Add ref sequence only once for query ranges having same start and end.
if (previousOverlappingRange == null || (previousOverlappingRange.Start != queryRange.Start && previousOverlappingRange.End != queryRange.End))
{
range = new SequenceRange(
refRange.ID,
Math.Max(queryRange.Start, refRange.Start),
Math.Min(queryRange.End, refRange.End));
result.Add(range);
CopyOfMetadata(range, refRange);
if (isParentSeqRangesRequired)
{
AddParent(range, refRange);
}
}
if (isParentSeqRangesRequired)
{
if (queryList.Contains(queryRange))
{
AddParent(range, queryRange);
}
else
{
if (queryRange.ParentSeqRanges.Count > 0)
{
AddParent(range, queryRange.ParentSeqRanges);
}
}
}
}
else
{
// Add ref sequence only once.
if (previousOverlappingRange == null)
{
range = new SequenceRange(refRange.ID, refRange.Start, refRange.End);
CopyOfMetadata(range, refRange);
result.Add(range);
if (isParentSeqRangesRequired)
{
AddParent(range, refRange);
}
else
{
break;
}
}
if (isParentSeqRangesRequired)
{
if (queryList.Contains(queryRange))
{
AddParent(range, queryRange);
}
else
{
if (queryRange.ParentSeqRanges.Count > 0)
{
AddParent(range, queryRange.ParentSeqRanges);
}
}
}
}
previousOverlappingRange = queryRange;
}
}
}
}
return result;
}
/// <summary>
/// Returns overlapping sequence ranges from this and specified SequenceRangeGroup for each group in this grouping.
///
/// For instance if you had in group 'Chr1' the following ranges:
///
/// Ranges in this instance Ranges in the query
/// 0 to 10 20 to 40
/// 30 to 50 70 to 100
/// 60 to 80 400 to 800
/// 300 to 500 850 to 900
/// 600 to 700 900 to 1200
/// 800 to 1000
///
/// Result for minOverlap set to 1
/// 1. If outputType is OverlappingPiecesOfIntervals.
/// 30 to 40
/// 70 to 80
/// 400 to 500
/// 600 o 700
/// 850 to 900
/// 900 to 1000
/// 2. If outputType is OverlappingIntervals
/// 30 to 50
/// 60 to 80
/// 300 to 500
/// 600 to 700
/// 800 to 1000
///
/// Running this method creates all new ISequenceRange objects and adds them
/// to the newly created SequenceRangeGrouping returned here.
/// </summary>
/// <param name="query">Query grouping.</param>
/// <param name="minOverlap">Minmum length of bases pairs should be overlapped.
/// By default this will be set to 1.</param>
/// <param name="outputType">
/// Type of output required, OverlappingPiecesOfIntervals or OverlappingIntervals.
/// By default this will be set to OverlappingPiecesOfIntervals that is only the base pairs that overlaps with
/// query ranges will be returned.</param>
/// <param name="isParentSeqRangesRequired">If this flag is set to true then the sequence ranges from
/// which the new sequence range is created are added to the ParentSeqRanges property of the
/// new sequence ranges.</param>
public SequenceRangeGrouping Intersect(SequenceRangeGrouping query, long minOverlap = 1, IntersectOutputType outputType = IntersectOutputType.OverlappingPiecesOfIntervals, bool isParentSeqRangesRequired = false)
{
SequenceRangeGrouping result = new SequenceRangeGrouping();
List <ISequenceRange> refSeqRanges = new List <ISequenceRange>();
List <ISequenceRange> querySeqRanges = new List <ISequenceRange>();
SequenceRange range = null;
// merge the query sequence ranges.
IList <ISequenceRange> queryList = null;
if (isParentSeqRangesRequired)
{
queryList = query.Flatten();
}
query = query.MergeOverlaps(0, isParentSeqRangesRequired);
foreach (string id in _groups.Keys)
{
refSeqRanges.Clear();
querySeqRanges.Clear();
refSeqRanges.AddRange(_groups[id]);
if (query._groups.ContainsKey(id))
{
querySeqRanges.AddRange(query._groups[id]);
querySeqRanges.Sort();
}
if (querySeqRanges.Count > 0)
{
foreach (ISequenceRange refRange in refSeqRanges)
{
IList <ISequenceRange> overlappingQueryRanges = GetOverlappingRenges(refRange, querySeqRanges, minOverlap);
if (overlappingQueryRanges == null || overlappingQueryRanges.Count == 0)
{
// If the minOverlap is lessthan or equal to zero and overlapping intervals are required.
// then add the ref seq to result.
if (minOverlap <= 0 && outputType == IntersectOutputType.OverlappingIntervals)
{
range = new SequenceRange(refRange.ID, refRange.Start, refRange.End);
CopyOfMetadata(range, refRange);
result.Add(range);
if (isParentSeqRangesRequired)
{
AddParent(range, refRange);
}
}
continue;
}
ISequenceRange previousOverlappingRange = null;
foreach (ISequenceRange queryRange in overlappingQueryRanges)
{
if (outputType == IntersectOutputType.OverlappingPiecesOfIntervals)
{
// Add ref sequence only once for query ranges having same start and end.
if (previousOverlappingRange == null || (previousOverlappingRange.Start != queryRange.Start && previousOverlappingRange.End != queryRange.End))
{
range = new SequenceRange(
refRange.ID,
Math.Max(queryRange.Start, refRange.Start),
Math.Min(queryRange.End, refRange.End));
result.Add(range);
CopyOfMetadata(range, refRange);
if (isParentSeqRangesRequired)
{
AddParent(range, refRange);
}
}
if (isParentSeqRangesRequired)
{
if (queryList.Contains(queryRange))
{
AddParent(range, queryRange);
}
else
{
if (queryRange.ParentSeqRanges.Count > 0)
{
AddParent(range, queryRange.ParentSeqRanges);
}
}
}
}
else
{
// Add ref sequence only once.
if (previousOverlappingRange == null)
{
range = new SequenceRange(refRange.ID, refRange.Start, refRange.End);
CopyOfMetadata(range, refRange);
result.Add(range);
if (isParentSeqRangesRequired)
{
AddParent(range, refRange);
}
else
{
break;
}
}
if (isParentSeqRangesRequired)
{
if (queryList.Contains(queryRange))
{
AddParent(range, queryRange);
}
else
{
if (queryRange.ParentSeqRanges.Count > 0)
{
AddParent(range, queryRange.ParentSeqRanges);
}
}
}
}
previousOverlappingRange = queryRange;
}
}
}
}
return(result);
}
/// <summary>
/// Validate Intersect SequenceRangeGrouping.
/// </summary>
/// <param name="nodeName">Xml Node name for different inputs.</param>
/// <param name="overlappingBasePair">Value of overlappingBasePair</param>
void IntersectSequenceRange(string nodeName,
bool overlappingBasePair, bool IsParentSeqRangeRequired)
{
// Get values from xml.
string[] expectedRangeIDs = _utilityObj._xmlUtil.GetTextValue(
nodeName, Constants.IDNode).Split(',');
string[] expectedStartIndex = _utilityObj._xmlUtil.GetTextValue(
nodeName, Constants.StartNode).Split(',');
string[] expectedEndIndex = _utilityObj._xmlUtil.GetTextValue(
nodeName, Constants.EndNode).Split(',');
string referenceFilePath = _utilityObj._xmlUtil.GetTextValue(
nodeName, Constants.FilePathNode);
string queryFilePath = _utilityObj._xmlUtil.GetTextValue(
nodeName, Constants.QueryFilePath);
string minimalOverlap = _utilityObj._xmlUtil.GetTextValue(
nodeName, Constants.OverlapValue);
string rangeID = string.Empty;
bool result = false;
List <ISequenceRange> rangeList = null;
// Parse a BED file.
BedParser parserObj = new BedParser();
SequenceRangeGrouping referenceGroup = parserObj.ParseRangeGrouping(referenceFilePath);
SequenceRangeGrouping queryGroup = parserObj.ParseRangeGrouping(queryFilePath);
IntersectOutputType outputType = IntersectOutputType.OverlappingIntervals;
if (overlappingBasePair)
{
outputType = IntersectOutputType.OverlappingPiecesOfIntervals;
}
// Intersect a SequenceRangeGroup.
SequenceRangeGrouping intersectGroup = referenceGroup.Intersect(queryGroup,
long.Parse(minimalOverlap, (IFormatProvider)null), outputType);
// Get a intersect SequenceGroup Id.
IEnumerable <string> groupIds = intersectGroup.GroupIDs;
int j = 0;
foreach (string grpID in groupIds)
{
rangeID = grpID;
rangeList = intersectGroup.GetGroup(rangeID);
// Validate intersect sequence range.
foreach (ISequenceRange range in rangeList)
{
Assert.AreEqual(expectedStartIndex[j], range.Start.ToString((IFormatProvider)null));
Assert.AreEqual(expectedEndIndex[j], range.End.ToString((IFormatProvider)null));
Assert.AreEqual(expectedRangeIDs[j], range.ID.ToString((IFormatProvider)null));
j++;
}
}
// Validate ParentSeqRanges.
result = ValidateParentSeqRange(intersectGroup,
referenceGroup, queryGroup, IsParentSeqRangeRequired);
Assert.IsTrue(result);
ApplicationLog.WriteLine(
"Bed Parser BVT: Successfully validated the intersect SequeID, Start and End Ranges");
Console.WriteLine(string.Format((IFormatProvider)null,
"Bed Parser BVT: Successfully validated the merged SequeID, Start and End Ranges"));
}
