public void ComputeSequenceRangeGroupingMetrics(SequenceRangeGrouping srg)
{
groups = 0L;
ranges = 0L;
bases = 0L;
foreach (string id in srg.GroupIDs)
{
++groups;
ranges += srg.GetGroup(id).Count;
foreach (SequenceRange sr in srg.GetGroup(id))
{
bases += sr.Length;
}
}
return;
}
/// <summary>
/// Formats and writes the query region (Output of Merge/Subtract/Intersect) operations
/// </summary>
/// <param name="resultWorkbook">
/// Workbook to which Range has to be written
/// </param>
/// <param name="resultSheetname">New worksheet name</param>
/// <param name="resultGroup">Output group</param>
/// <param name="groupsData">
/// Complete input groups information
/// Contains individual Group, sheet and addresses of ISequenceRange
/// </param>
private void WriteSequenceRange(
Workbook resultWorkbook,
string resultSheetname,
SequenceRangeGrouping resultGroup,
Dictionary<SequenceRangeGrouping, GroupData> groupsData,
bool showMetadata,
bool showBasePairCount)
{
if (resultGroup.GroupIDs.Count() > 0)
{
int baseRowIndex = 2, baseColumnIndex = 2;
int dataRowIndex = 0, dataColumnIndex = 0;
int totalColumnCount = 0;
object[,] values;
List<string> hyperlinks = null;
List<ISequenceRange> resultSequenceRanges = null;
Dictionary<SequenceRangeGrouping, Dictionary<string, int>> groupSheetIndices = null;
Dictionary<int, Tuple<SequenceRangeGrouping, bool, List<ISequenceRange>>> columnData = null;
Dictionary<ISequenceRange, string> rangedata = null;
Dictionary<SequenceRangeGrouping, SequenceRangeGrouping> allSheetData = null;
Dictionary<SequenceRangeGrouping, int> allSheetCount = null;
SequenceRangeGrouping groupToMerge = null;
SequenceRangeGrouping referenceGroup = null;
SequenceRangeGrouping queryGroup = null;
SequenceRangeGrouping sheetGroup = null;
int sheetCount = 0;
Range activeRange = null;
var resultWorksheet =
resultWorkbook.Worksheets.Add(
Type.Missing,
resultWorkbook.Worksheets.get_Item(resultWorkbook.Worksheets.Count),
Type.Missing,
Type.Missing) as Worksheet;
((_Worksheet)resultWorksheet).Activate();
Globals.ThisAddIn.Application.ActiveWindow.Zoom = ZoomLevel;
resultWorksheet.Name = resultSheetname;
activeRange = resultWorksheet.get_Range(GetColumnString(baseColumnIndex) + baseRowIndex, Type.Missing);
rangedata = groupsData.Values.Select(gd => gd.Metadata) // Get the Metadata
.SelectMany(sd => sd.Values).ToList() // Get the Dictionary
.SelectMany(rd => rd).ToList().ToDictionary(k => k.Key, v => v.Value); // Convert to dictionary
groupSheetIndices = new Dictionary<SequenceRangeGrouping, Dictionary<string, int>>();
baseRowIndex = this.WriteSequenceRangeHeader(
resultWorksheet,
groupSheetIndices,
groupsData,
baseRowIndex,
baseColumnIndex,
ref totalColumnCount,
showMetadata,
showBasePairCount);
totalColumnCount -= (baseColumnIndex - 1);
foreach (string resultGroupKey in resultGroup.GroupIDs)
{
resultSequenceRanges = resultGroup.GetGroup(resultGroupKey);
dataRowIndex = 0;
values = new object[resultSequenceRanges.Count, totalColumnCount];
activeRange = resultWorksheet.get_Range(
GetColumnString(baseColumnIndex) + baseRowIndex,
Missing.Value);
activeRange = activeRange.get_Resize(resultSequenceRanges.Count, totalColumnCount);
foreach (ISequenceRange resultSequenceRange in resultSequenceRanges)
{
referenceGroup = null;
queryGroup = null;
dataColumnIndex = 0;
allSheetData = new Dictionary<SequenceRangeGrouping, SequenceRangeGrouping>();
allSheetCount = new Dictionary<SequenceRangeGrouping, int>();
values[dataRowIndex, dataColumnIndex] = resultSequenceRange.ID;
dataColumnIndex++;
values[dataRowIndex, dataColumnIndex] = resultSequenceRange.Start;
dataColumnIndex++;
values[dataRowIndex, dataColumnIndex] = resultSequenceRange.End;
dataColumnIndex++;
if (showMetadata)
{
for (int index = 3; index < rangeHeaders.Count; index++)
{
values[dataRowIndex, dataColumnIndex] = ExtractRangeMetadata(
resultSequenceRange,
rangeHeaders[index]);
dataColumnIndex++;
}
}
columnData = PrepareSequenceRowRange(
groupsData,
groupSheetIndices,
rangedata,
resultSequenceRange);
foreach (var columnGroup in columnData)
{
if (showBasePairCount)
{
// Get the parent ranges for Group's range in a column
groupToMerge = new SequenceRangeGrouping(columnGroup.Value.Item3);
if (1 < columnGroup.Value.Item3.Count)
{
groupToMerge = groupToMerge.MergeOverlaps(0, false);
}
// Render data for Group's range in a column
values[dataRowIndex, columnGroup.Key] =
groupToMerge.GroupRanges.Sum(sr => sr.End - sr.Start);
values[dataRowIndex, columnGroup.Key + 1] = columnGroup.Value.Item3.Count;
}
else
{
values[dataRowIndex, columnGroup.Key] = columnGroup.Value.Item3.Count;
}
// Let the hyperlink added
hyperlinks = new List<string>();
foreach (ISequenceRange range in columnGroup.Value.Item3)
{
hyperlinks.AddRange(rangedata[range].Split(','));
}
this.ShowHyperlink(
hyperlinks,
activeRange,
columnGroup.Key,
dataRowIndex,
showBasePairCount);
if (showBasePairCount)
{
// Calculate data for all group
if (allSheetData.TryGetValue(columnGroup.Value.Item1, out sheetGroup))
{
allSheetData[columnGroup.Value.Item1] = sheetGroup.MergeOverlaps(
groupToMerge,
0,
false);
}
else
{
allSheetData[columnGroup.Value.Item1] = groupToMerge;
}
// Build up reference & query groups (later get common range using this)
if (columnGroup.Value.Item2)
{
if (null == referenceGroup)
{
referenceGroup = groupToMerge;
}
else
{
referenceGroup = referenceGroup.MergeOverlaps(groupToMerge, 0, false);
}
}
else
{
if (null == queryGroup)
{
queryGroup = groupToMerge;
}
else
{
queryGroup = queryGroup.MergeOverlaps(groupToMerge, 0, false);
}
}
}
// Calculate range count for all group
if (allSheetCount.TryGetValue(columnGroup.Value.Item1, out sheetCount))
{
allSheetCount[columnGroup.Value.Item1] += columnGroup.Value.Item3.Count;
}
else
{
allSheetCount[columnGroup.Value.Item1] = columnGroup.Value.Item3.Count;
}
}
// Render all columns in SequenceRangeGrouping
foreach (var allData in allSheetCount)
{
dataColumnIndex = groupSheetIndices[allData.Key].Values.Min() - (showBasePairCount ? 2 : 1);
if (showBasePairCount)
{
values[dataRowIndex, dataColumnIndex] =
allSheetData[allData.Key].GroupRanges.Sum(sr => sr.End - sr.Start);
dataColumnIndex++;
}
values[dataRowIndex, dataColumnIndex] = allData.Value;
}
if (showBasePairCount)
{
// Render common column in SequenceRangeGrouping
if (null != referenceGroup && null != queryGroup)
{
referenceGroup = referenceGroup.Intersect(
queryGroup,
0,
IntersectOutputType.OverlappingPiecesOfIntervals,
false);
values[dataRowIndex, totalColumnCount - 1] =
referenceGroup.GroupRanges.Sum(sr => sr.End - sr.Start);
}
else
{
values[dataRowIndex, totalColumnCount - 1] = 0;
}
}
dataRowIndex++;
}
activeRange.set_Value(Missing.Value, values);
baseRowIndex += dataRowIndex;
}
resultWorksheet.Columns.AutoFit();
this.NormalizeColumWidths(resultWorksheet.UsedRange);
this.EnableAllControls();
}
else
{
MessageBox.Show(
Resources.NO_RESULT,
Resources.CAPTION,
MessageBoxButtons.OK,
MessageBoxIcon.Information);
}
}
/// <summary>
/// Method to validate parent seq ranges in result.
/// </summary>
/// <param name="resultSeqRange">Result seq range group.</param>
/// <param name="refSeqRange">Reference seq range group.</param>
/// <param name="querySeqRange">Query seq range group.</param>
/// <param name="isParentSeqRangeRequired">Flag to indicate whether result should contain parent seq ranges or not.</param>
/// <returns>Returns true if the parent seq ranges are valid; otherwise returns false.</returns>
private static bool ValidateParentSeqRange(SequenceRangeGrouping resultSeqRange, SequenceRangeGrouping refSeqRange,
SequenceRangeGrouping querySeqRange, bool isParentSeqRangeRequired)
{
IList<ISequenceRange> refSeqRangeList = new List<ISequenceRange>();
IList<ISequenceRange> querySeqRangeList = new List<ISequenceRange>();
foreach (string groupid in resultSeqRange.GroupIDs)
{
if (refSeqRange != null)
{
refSeqRangeList = refSeqRange.GetGroup(groupid);
}
if (querySeqRange != null)
{
querySeqRangeList = querySeqRange.GetGroup(groupid);
}
foreach (ISequenceRange resultRange in resultSeqRange.GetGroup(groupid))
{
if (!isParentSeqRangeRequired)
{
if (resultRange.ParentSeqRanges.Count != 0)
{
return false;
}
}
else
{
int refCount = refSeqRangeList.Where(R => resultRange.ParentSeqRanges.Contains(R)).Count();
int queryCount = querySeqRangeList.Where(R => resultRange.ParentSeqRanges.Contains(R)).Count();
if (refCount + queryCount != resultRange.ParentSeqRanges.Count)
{
return false;
}
}
}
}
return true;
}
/// <summary>
/// Write source sequence ranges to the given workbook in a new sheet
/// </summary>
/// <param name="sourceSequenceRanges">Source sequence ranges</param>
/// <param name="sheetName">Name to be given for the new sheet</param>
/// <param name="targetWorkbook">Workbook in which the sheet has to be added</param>
/// <returns>Newly created sheet with source data.</returns>
private static Worksheet DisplaySourceData(SequenceRangeGrouping sourceSequenceRanges, string sheetName, Workbook targetWorkbook)
{
//create new sheet
Worksheet outputSheet = targetWorkbook.Sheets.Add(Type.Missing, targetWorkbook.Sheets[targetWorkbook.Sheets.Count], 1, XlSheetType.xlWorksheet);
outputSheet.Name = sheetName;
targetWorkbook.Application.ScreenUpdating = false;
targetWorkbook.Application.EnableEvents = false;
try
{
// write the header
outputSheet.Range["A1", "C1"].Value2 = BedHeaders;
// write bed data
int currentRow = 2;
foreach (string groupID in sourceSequenceRanges.GroupIDs)
{
Range outputRange = WriteSequenceRangeAt(outputSheet.Cells[currentRow, 1], sourceSequenceRanges.GetGroup(groupID), false);
currentRow += outputRange.Rows.Count;
}
outputSheet.UsedRange.Columns.AutoFit();
}
finally
{
targetWorkbook.Application.ScreenUpdating = true;
targetWorkbook.Application.EnableEvents = true;
}
return outputSheet;
}
/// <summary>
/// This method will dump the region overlap data to a sheet in the NodeXL workbook.
/// </summary>
/// <param name="outputSheet">Sheet to which the data should be dumped to</param>
/// <param name="srgOnly_A">Only A</param>
/// <param name="srgOnly_B">Only A</param>
/// <param name="srgOnly_AB">Only A</param>
/// <returns>Worksheet after writing data</returns>
private static Worksheet WriteOverlapData(Worksheet outputSheet, SequenceRangeGrouping srgOnly_A, SequenceRangeGrouping srgOnly_B, SequenceRangeGrouping srgOnly_AB)
{
outputSheet.Application.ScreenUpdating = false;
outputSheet.Application.EnableEvents = false;
List<ISequenceRange> seqs_AList = null;
List<ISequenceRange> seqs_BList = null;
List<ISequenceRange> seqs_ABList = null;
int dataStartRow = 7;
int currentRow;
try
{
// write the header
outputSheet.Range["A2"].Value2 = Resources.RegionsCountLabel;
outputSheet.Range["A3"].Value2 = Resources.BasePairsCountLabel;
outputSheet.Range["A4"].Value2 = Resources.PerOfBasePairsInRegionLabel;
outputSheet.Range["D1"].Value2 = Resources.OnlyA;
outputSheet.Range["E1"].Value2 = Resources.OnlyB;
outputSheet.Range["F1"].Value2 = Resources.OnlyAB;
outputSheet.Range["G1"].Value2 = Resources.Total;
outputSheet.Range["A6", "F6"].Value2 = BedHeadersForTwoInput;
outputSheet.Range["A6", "F6"].Cells.Borders[XlBordersIndex.xlEdgeBottom].Weight = XlBorderWeight.xlThin;
outputSheet.Range["A1", "F1"].Cells.HorizontalAlignment = XlHAlign.xlHAlignCenter;
outputSheet.Range["A6", "F6"].Cells.HorizontalAlignment = XlHAlign.xlHAlignCenter;
currentRow = dataStartRow;
// Get all groupID's in all ranges
List<string> groupIDs = new List<string>();
groupIDs.AddRange(srgOnly_A.GroupIDs);
groupIDs.AddRange(srgOnly_B.GroupIDs);
groupIDs.AddRange(srgOnly_AB.GroupIDs);
int prevRow = dataStartRow;
// Display all overlap data
foreach (string groupID in groupIDs.Distinct())
{
seqs_AList = srgOnly_A.GetGroup(groupID);
seqs_BList = srgOnly_B.GetGroup(groupID);
seqs_ABList = srgOnly_AB.GetGroup(groupID);
if (seqs_AList == null) seqs_AList = new List<ISequenceRange>();
if (seqs_BList == null) seqs_BList = new List<ISequenceRange>();
if (seqs_ABList == null) seqs_ABList = new List<ISequenceRange>();
int indexA = 0;
int indexB = 0;
int indexAB = 0;
object[,] output = new object[seqs_AList.Count + seqs_BList.Count + seqs_ABList.Count, 6];
while (indexA < seqs_AList.Count || indexB < seqs_BList.Count || indexAB < seqs_ABList.Count)
{
ISequenceRange a = indexA < seqs_AList.Count ? seqs_AList[indexA] : null;
ISequenceRange b = indexB < seqs_BList.Count ? seqs_BList[indexB] : null;
ISequenceRange ab = indexAB < seqs_ABList.Count ? seqs_ABList[indexAB] : null;
ISequenceRange range = GetSmallestSeqRangeToDisplay(a, b, ab);
if (range == null)
{
indexA++;
indexB++;
indexAB++;
continue;
}
output[currentRow - prevRow, 0] = range.ID;
output[currentRow - prevRow, 1] = range.Start;
output[currentRow - prevRow, 2] = range.End;
if (range == a)
{
// display
output[currentRow - prevRow, 3] = Math.Abs(range.End - range.Start);
indexA++;
}
else if (range == b)
{
// display
output[currentRow - prevRow, 4] = Math.Abs(range.End - range.Start);
indexB++;
}
else
{
// display
output[currentRow - prevRow, 5] = Math.Abs(range.End - range.Start);
indexAB++;
}
currentRow++;
}
outputSheet.Range["A" + prevRow.ToString(), "F" + (currentRow -1).ToString()].Value2 = output;
prevRow = currentRow;
}
string formula = string.Format(CultureInfo.InvariantCulture, CountFormulaFormat, "D", dataStartRow, "D", currentRow - 1);
outputSheet.Range["D2"].Formula = formula;
formula = string.Format(CultureInfo.InvariantCulture, CountFormulaFormat, "E", dataStartRow, "E", currentRow - 1);
outputSheet.Range["E2"].Formula = formula;
formula = string.Format(CultureInfo.InvariantCulture, CountFormulaFormat, "F", dataStartRow, "F", currentRow - 1);
outputSheet.Range["F2"].Formula = formula;
formula = string.Format(CultureInfo.InvariantCulture, SumFormulaFormat, "D", 2, "F", 2);
outputSheet.Range["G2"].Formula = formula;
formula = string.Format(CultureInfo.InvariantCulture, SumFormulaFormat, "D", dataStartRow, "D", currentRow - 1);
outputSheet.Range["D3"].Formula = formula;
formula = string.Format(CultureInfo.InvariantCulture, SumFormulaFormat, "E", dataStartRow, "E", currentRow - 1);
outputSheet.Range["E3"].Formula = formula;
formula = string.Format(CultureInfo.InvariantCulture, SumFormulaFormat, "F", dataStartRow, "F", currentRow - 1);
outputSheet.Range["F3"].Formula = formula;
formula = string.Format(CultureInfo.InvariantCulture, SumFormulaFormat, "D", 3, "F", 3);
outputSheet.Range["G3"].Formula = formula;
outputSheet.Range["D4"].Formula = "=D3/G3";
outputSheet.Range["E4"].Formula = "=E3/G3";
outputSheet.Range["F4"].Formula = "=F3/G3";
formula = string.Format(CultureInfo.InvariantCulture, SumFormulaFormat, "D", 4, "F", 4);
outputSheet.Range["G4"].Formula = formula;
outputSheet.Range["D4", "G4"].Cells.NumberFormat = "0.00%";
outputSheet.UsedRange.Columns.AutoFit();
}
finally
{
outputSheet.Application.ScreenUpdating = true;
outputSheet.Application.EnableEvents = true;
}
return outputSheet;
}
/// <summary>
/// Display Sequence range grops
/// </summary>
/// <param name="seqRangeGrops">Sequence Ranges grops</param>
private static void DisplaySequenceRange(SequenceRangeGrouping seqRangeGrop)
{
IEnumerable<string> rangeGroupIds = seqRangeGrop.GroupIDs;
string rangeID = string.Empty;
// Display Sequence Ranges
Console.Write("\r\nChromosome\t\tStart\tEnd");
foreach (string groupID in rangeGroupIds)
{
rangeID = groupID;
// Get SequenceRangeIds.
List<ISequenceRange> rangeList = seqRangeGrop.GetGroup(rangeID);
foreach (ISequenceRange seqRange in rangeList)
{
Console.Write("\n{0}\t\t\t{1}\t{2}", seqRange.ID.ToString(),
seqRange.Start.ToString(), seqRange.End.ToString());
}
}
}
// default printing of SequenceRangeGrouping
//
public static void SequenceRangeGroupingToString(SequenceRangeGrouping srg, string name)
{
Console.Error.Write("[{0}] : SeqeuenceRangeGrouping: ", name);
var srgm = new SequenceRangeGroupingMetrics(srg);
Console.Error.WriteLine("{0}, {1}, {2}", srgm.groups, srgm.ranges, srgm.bases);
foreach (string id in srg.GroupIDs)
{
Console.Error.WriteLine("--GroupID: {0}, {1}", id, srg.GetGroup(id).Count());
ListSequenceRangeToString(srg.GetGroup(id));
}
Console.Error.WriteLine();
}