static int Main(string[] args)
{
CanvasCommon.Utilities.LogCommandLine(args);
string inFile = null;
string outFile = null;
bool needHelp = false;
bool isGermline = false;
string bedPath = null;
double alpha = Segmentation.DefaultAlpha;
SegmentSplitUndo undoMethod = SegmentSplitUndo.None;
SegmentationMethod partitionMethod = SegmentationMethod.Wavelets;
int maxInterBinDistInSegment = 1000000;
OptionSet p = new OptionSet()
{
{ "i|infile=", "input file - usually generated by CanvasClean", v => inFile = v },
{ "o|outfile=", "text file to output", v => outFile = v },
{ "h|help", "show this message and exit", v => needHelp = v != null },
{ "a|alpha=", "alpha parameter to CBS. Default: " + alpha, v => alpha = float.Parse(v) },
{ "m|method=", "segmentation method (Wavelets/CBS). Default: " + partitionMethod, v => partitionMethod = (SegmentationMethod)Enum.Parse(typeof(SegmentationMethod), v) },
{ "s|split=", "CBS split method (None/Prune/SDUndo). Default: " + undoMethod, v => undoMethod = (SegmentSplitUndo)Enum.Parse(typeof(SegmentSplitUndo), v) },
{ "b|bedfile=", "bed file to exclude (don't span these intervals)", v => bedPath = v },
{ "g|germline", "flag indicating that input file represents germline genome", v => isGermline = v != null },
{ "d|maxInterBinDistInSegment=", "the maximum distance between adjacent bins in a segment (negative numbers turn off splitting segments after segmentation). Default: " + maxInterBinDistInSegment, v => maxInterBinDistInSegment = int.Parse(v) },
};
List <string> extraArgs = p.Parse(args);
if (needHelp)
{
ShowHelp(p);
return(0);
}
if (inFile == null || outFile == null)
{
ShowHelp(p);
return(0);
}
if (!File.Exists(inFile))
{
Console.WriteLine("CanvasPartition.exe: File {0} does not exist! Exiting.", inFile);
return(1);
}
if (!string.IsNullOrEmpty(bedPath) && !File.Exists(bedPath))
{
Console.WriteLine("CanvasPartition.exe: File {0} does not exist! Exiting.", bedPath);
return(1);
}
// no command line parameter for segmentation method
Segmentation SegmentationEngine = new Segmentation(inFile, bedPath, maxInterBinDistInSegment: maxInterBinDistInSegment);
SegmentationEngine.Alpha = alpha;
SegmentationEngine.UndoMethod = undoMethod;
SegmentationEngine.SegmentGenome(outFile, partitionMethod, isGermline);
return(0);
}
public CBSRunner(int maxInterBinDistInSegment, SegmentSplitUndo undoMethod, double alpha)
{
_maxInterBinDistInSegment = maxInterBinDistInSegment;
_undoMethod = undoMethod;
_alpha = alpha;
}
/// <summary>
/// Outputs:
/// lengthSeg
/// segmentMeans
/// </summary>
/// <param name="genomeData"></param>
/// <param name="sbdry"></param>
/// <param name="lengthSeg">segment lengths</param>
/// <param name="segmentMeans">segment means</param>
/// <param name="dataType">"logratio" or "binary"</param>
/// <param name="alpha"></param>
/// <param name="nPerm"></param>
/// <param name="pMethod"></param>
/// <param name="minWidth"></param>
/// <param name="kMax"></param>
/// <param name="nMin"></param>
/// <param name="trimmedSD"></param>
/// <param name="undoSplits">"none" or "prune" or "sdundo"</param>
/// <param name="undoPrune"></param>
/// <param name="undoSD"></param>
/// <param name="verbose"></param>
/// <param name="nGrid"></param>
/// <param name="tol"></param>
public static void ChangePoints(double[] genomeData, uint[] sbdry,
out int[] lengthSeg, out double[] segmentMeans, Random rnd,
string dataType = "logratio", double alpha = 0.01,
uint nPerm = 10000, string pMethod = "hybrid", int minWidth = 2, int kMax = 25,
uint nMin = 200, double trimmedSD = -1, SegmentSplitUndo undoSplits = SegmentSplitUndo.None,
double undoPrune = 0.05, double undoSD = 3, int verbose = 1,
int nGrid = 100, double tol = 1E-6)
{
//int n = genomeData.Length;
if (trimmedSD <= 0)
{
trimmedSD = Helper.MedianAbsoluteDeviation(Helper.Diff(genomeData)) / Math.Sqrt(2);
}
// start with the whole
List<int> segEnd = new List<int>();
segEnd.Add(0); // inclusive
segEnd.Add(genomeData.Length); // exclusive
int k = segEnd.Count;
List<int> changeLocations = new List<int>();
int nChangePoints = 0;
int[] iChangePoint = null;
while (k > 1)
{
int currentN = segEnd[k - 1] - segEnd[k - 2];
if (verbose >= 3)
{
Console.Write(".... current segment: {0} - {1} \n", segEnd[k - 2] + 1, segEnd[k - 1]);
}
if (currentN >= 2 * minWidth)
{
double[] currentGenomeData = new double[currentN];
Array.Copy(genomeData, segEnd[k - 2], currentGenomeData, 0, currentN);
// check whether hybrid method needs to be used
bool hybrid = false;
double delta = 0.0;
if (pMethod.Equals("hybrid") && nMin < currentN)
{
hybrid = true;
delta = (kMax + 1.0) / currentN;
}
// if all values of current.genomdat are the same don't segment
if (currentGenomeData.Max() == currentGenomeData.Min())
{
nChangePoints = 0;
}
else
{
// centering the current data will save a lot of computations later
double currentAverage = currentGenomeData.Average();
Helper.InplaceSub(currentGenomeData, currentAverage);
// need total sum of squares too
double currentTSS = Helper.WeightedSumOfSquares(currentGenomeData, null);
ChangePoint.FindChangePoints(currentGenomeData, currentTSS, nPerm, alpha,
out nChangePoints, out iChangePoint, dataType.Equals("binary"),
hybrid, minWidth, kMax, delta, nGrid, sbdry, tol, rnd);
}
}
else
{
nChangePoints = 0;
}
// Save the change location
// segEnd[k - 1] will be removed when nChangePoints == 0
if (nChangePoints == 0) { changeLocations.Add(segEnd[k - 1]); }
// Offset iChangePoint by segEnd[k - 2]
for (int i = 0; i < nChangePoints; i++) { iChangePoint[i] += segEnd[k - 2]; }
switch (nChangePoints) // switch by the number of change points
{
case 0: // no change point
segEnd.RemoveAt(k - 1); // Remove the last element
break;
case 1: // one change point
segEnd.Insert(k - 1, iChangePoint[0]);
break;
case 2: // two change points
segEnd.InsertRange(k - 1, iChangePoint);
break;
default:
Console.Error.WriteLine("There should be 0, 1, or 2 change points");
break;
}
k = segEnd.Count;
if (verbose >= 3) { Console.Write(".... segments to go: {0} \n", String.Join(" ", segEnd)); }
}
changeLocations.Reverse(); // changeLocations is no longer needed
List<int> segEnds = changeLocations;
int nSeg = segEnds.Count;
segEnds.Insert(0, 0);
lengthSeg = Helper.Diff(segEnds.ToArray());
if (nSeg > 1)
{
if (undoSplits == SegmentSplitUndo.Prune)
{
lengthSeg = ChangePointsPrune(genomeData, lengthSeg, changeCutoff: undoPrune);
}
if (undoSplits == SegmentSplitUndo.SDUndo)
{
lengthSeg = ChangePointsSDUndo(genomeData, lengthSeg, trimmedSD, changeSD: undoSD);
}
}
segmentMeans = new double[lengthSeg.Length];
int ll = 0, uu = 0;
for (int i = 0; i < lengthSeg.Length; i++)
{
uu += lengthSeg[i];
// Works even if weights == null
segmentMeans[i] = Helper.WeightedAverage(genomeData, null, iStart: ll, iEnd: uu);
ll = uu;
}
}
/// <summary>
/// Outputs:
/// lengthSeg
/// segmentMeans
/// </summary>
/// <param name="genomeData"></param>
/// <param name="sbdry"></param>
/// <param name="lengthSeg">segment lengths</param>
/// <param name="segmentMeans">segment means</param>
/// <param name="dataType">"logratio" or "binary"</param>
/// <param name="alpha"></param>
/// <param name="nPerm"></param>
/// <param name="pMethod"></param>
/// <param name="minWidth"></param>
/// <param name="kMax"></param>
/// <param name="nMin"></param>
/// <param name="trimmedSD"></param>
/// <param name="undoSplits">"none" or "prune" or "sdundo"</param>
/// <param name="undoPrune"></param>
/// <param name="undoSD"></param>
/// <param name="verbose"></param>
/// <param name="nGrid"></param>
/// <param name="tol"></param>
public static void ChangePoints(double[] genomeData, uint[] sbdry,
out int[] lengthSeg, out double[] segmentMeans, Random rnd,
string dataType = "logratio", double alpha = 0.01,
uint nPerm = 10000, string pMethod = "hybrid", int minWidth = 2, int kMax = 25,
uint nMin = 200, double trimmedSD = -1, SegmentSplitUndo undoSplits = SegmentSplitUndo.None,
double undoPrune = 0.05, double undoSD = 3, int verbose = 1,
int nGrid = 100, double tol = 1E-6)
{
if (trimmedSD <= 0)
{
trimmedSD = Helper.MedianAbsoluteDeviation(Helper.Diff(genomeData)) / Math.Sqrt(2);
}
// start with the whole
List <int> segEnd = new List <int>();
segEnd.Add(0); // inclusive
segEnd.Add(genomeData.Length); // exclusive
int k = segEnd.Count;
List <int> changeLocations = new List <int>();
int nChangePoints = 0;
int[] iChangePoint = null;
while (k > 1)
{
int currentN = segEnd[k - 1] - segEnd[k - 2];
if (verbose >= 3)
{
Console.Write(".... current segment: {0} - {1} \n", segEnd[k - 2] + 1, segEnd[k - 1]);
}
if (currentN >= 2 * minWidth)
{
double[] currentGenomeData = new double[currentN];
Array.Copy(genomeData, segEnd[k - 2], currentGenomeData, 0, currentN);
// check whether hybrid method needs to be used
bool hybrid = false;
double delta = 0.0;
if (pMethod.Equals("hybrid") && nMin < currentN)
{
hybrid = true;
delta = (kMax + 1.0) / currentN;
}
// if all values of current.genomdat are the same don't segment
if (currentGenomeData.Max() == currentGenomeData.Min())
{
nChangePoints = 0;
}
else
{
// centering the current data will save a lot of computations later
double currentAverage = currentGenomeData.Average();
Helper.InplaceSub(currentGenomeData, currentAverage);
// need total sum of squares too
double currentTSS = Helper.WeightedSumOfSquares(currentGenomeData, null);
ChangePoint.FindChangePoints(currentGenomeData, currentTSS, nPerm, alpha,
out nChangePoints, out iChangePoint, dataType.Equals("binary"),
hybrid, minWidth, kMax, delta, nGrid, sbdry, tol, rnd);
}
}
else
{
nChangePoints = 0;
}
// Save the change location
// segEnd[k - 1] will be removed when nChangePoints == 0
if (nChangePoints == 0)
{
changeLocations.Add(segEnd[k - 1]);
}
// Offset iChangePoint by segEnd[k - 2]
for (int i = 0; i < nChangePoints; i++)
{
iChangePoint[i] += segEnd[k - 2];
}
switch (nChangePoints) // switch by the number of change points
{
case 0: // no change point
segEnd.RemoveAt(k - 1); // Remove the last element
break;
case 1: // one change point
segEnd.Insert(k - 1, iChangePoint[0]);
break;
case 2: // two change points
segEnd.InsertRange(k - 1, iChangePoint);
break;
default:
Console.Error.WriteLine("There should be 0, 1, or 2 change points");
break;
}
k = segEnd.Count;
if (verbose >= 3)
{
Console.Write(".... segments to go: {0} \n", String.Join(" ", segEnd));
}
}
changeLocations.Reverse(); // changeLocations is no longer needed
List <int> segEnds = changeLocations;
int nSeg = segEnds.Count;
segEnds.Insert(0, 0);
lengthSeg = Helper.Diff(segEnds.ToArray());
if (nSeg > 1)
{
if (undoSplits == SegmentSplitUndo.Prune)
{
lengthSeg = ChangePointsPrune(genomeData, lengthSeg, changeCutoff: undoPrune);
}
if (undoSplits == SegmentSplitUndo.SDUndo)
{
lengthSeg = ChangePointsSDUndo(genomeData, lengthSeg, trimmedSD, changeSD: undoSD);
}
}
segmentMeans = new double[lengthSeg.Length];
int ll = 0, uu = 0;
for (int i = 0; i < lengthSeg.Length; i++)
{
uu += lengthSeg[i];
// Works even if weights == null
segmentMeans[i] = Helper.WeightedAverage(genomeData, null, iStart: ll, iEnd: uu);
ll = uu;
}
}
static int Main(string[] args)
{
CanvasCommon.Utilities.LogCommandLine(args);
List <string> inFiles = new List <string>();
List <string> outFiles = new List <string>();
bool needHelp = false;
bool isGermline = false;
string bedPath = null;
string commonCNVsbedPath = null;
double alpha = CBSRunner.DefaultAlpha;
double madFactor = WaveletsRunner.DefaultMadFactor;
SegmentSplitUndo undoMethod = SegmentSplitUndo.None;
Segmentation.SegmentationMethod partitionMethod = Segmentation.SegmentationMethod.Wavelets;
int maxInterBinDistInSegment = 1000000;
OptionSet p = new OptionSet()
{
{ "i|infile=", "input file - usually generated by CanvasClean", v => inFiles.Add(v) },
{ "o|outfile=", "text file to output", v => outFiles.Add(v) },
{ "h|help", "show this message and exit", v => needHelp = v != null },
{ "m|method=", "segmentation method (Wavelets/CBS). Default: " + partitionMethod, v => partitionMethod = (Segmentation.SegmentationMethod)Enum.Parse(typeof(Segmentation.SegmentationMethod), v) },
{ "a|alpha=", "alpha parameter to CBS. Default: " + alpha, v => alpha = float.Parse(v) },
{ "s|split=", "CBS split method (None/Prune/SDUndo). Default: " + undoMethod, v => undoMethod = (SegmentSplitUndo)Enum.Parse(typeof(SegmentSplitUndo), v) },
{ "f|madFactor=", "MAD factor to Wavelets. Default: " + madFactor, v => madFactor = float.Parse(v) },
{ "b|bedfile=", "bed file to exclude (don't span these intervals)", v => bedPath = v },
{ "c|commoncnvs=", "bed file with common CNVs (always include these intervals into segmentation results)", v => commonCNVsbedPath = v },
{ "g|germline", "flag indicating that input file represents germline genome", v => isGermline = v != null },
{ "d|maxInterBinDistInSegment=", "the maximum distance between adjacent bins in a segment (negative numbers turn off splitting segments after segmentation). Default: " + maxInterBinDistInSegment, v => maxInterBinDistInSegment = int.Parse(v) },
};
List <string> extraArgs = p.Parse(args);
if (needHelp)
{
ShowHelp(p);
return(0);
}
if (!inFiles.Any() || !outFiles.Any())
{
ShowHelp(p);
return(0);
}
if (inFiles.Any(inFile => !File.Exists(inFile)))
{
Console.WriteLine("CanvasPartition.exe: File {0} does not exist! Exiting.", inFiles);
return(1);
}
if (!string.IsNullOrEmpty(bedPath) && !File.Exists(bedPath))
{
Console.WriteLine("CanvasPartition.exe: File {0} does not exist! Exiting.", bedPath);
return(1);
}
if (partitionMethod != Segmentation.SegmentationMethod.HMM && outFiles.Count > 1)
{
Console.WriteLine("CanvasPartition.exe: SegmentationMethod.HMM only works for MultiSample SPW worlfow, " +
"please provide multiple -o arguments");
return(1);
}
if (partitionMethod == Segmentation.SegmentationMethod.HMM && inFiles.Count == 1)
{
Console.WriteLine("CanvasPartition.exe: method=HMM option only works when more than one input files (-i) are provided");
return(1);
}
List <Segmentation> segmentationEngine = inFiles.Select(inFile => new Segmentation(inFile, bedPath, maxInterBinDistInSegment)).ToList();
Segmentation.GenomeSegmentationResults segmentationResults;
switch (partitionMethod)
{
default: // use Wavelets if CBS is not selected
Console.WriteLine("{0} Running Wavelet Partitioning", DateTime.Now);
WaveletsRunner waveletsRunner = new WaveletsRunner(new WaveletsRunner.WaveletsRunnerParams(isGermline, commonCNVsbedPath, madFactor: madFactor, verbose: 2));
segmentationResults = new Segmentation.GenomeSegmentationResults(waveletsRunner.Run(segmentationEngine.Single()));
segmentationEngine.Single().WriteCanvasPartitionResults(outFiles.Single(), segmentationResults);
break;
case Segmentation.SegmentationMethod.CBS:
Console.WriteLine("{0} Running CBS Partitioning", DateTime.Now);
CBSRunner cbsRunner = new CBSRunner(maxInterBinDistInSegment, undoMethod, alpha);
segmentationResults = new Segmentation.GenomeSegmentationResults(cbsRunner.Run(segmentationEngine.Single(), verbose: 2));
segmentationEngine.Single().WriteCanvasPartitionResults(outFiles.Single(), segmentationResults);
break;
case Segmentation.SegmentationMethod.HMM:
Console.WriteLine("{0} Running HMM Partitioning", DateTime.Now);
HiddenMarkovModelsRunner hiddenMarkovModelsRunner = new HiddenMarkovModelsRunner(commonCNVsbedPath, inFiles.Count);
segmentationResults = new Segmentation.GenomeSegmentationResults(hiddenMarkovModelsRunner.Run(segmentationEngine));
for (int i = 0; i < segmentationEngine.Count; i++)
{
segmentationEngine[i].WriteCanvasPartitionResults(outFiles[i], segmentationResults);
}
break;
}
Console.WriteLine("{0} CanvasPartition results written out", DateTime.Now);
return(0);
}
static int Main(string[] args)
{
CanvasCommon.Utilities.LogCommandLine(args);
List <string> cleanedFiles = new List <string>();
List <string> outPartitionedFiles = new List <string>();
List <string> vafFiles = new List <string>();
bool needHelp = false;
bool isGermline = false;
string filterBedFile = null;
string referenceFolder = null;
string commonCNVsbedPath = null;
string evennessMetricFile = null;
SegmentSplitUndo undoMethod = SegmentSplitUndo.None;
SegmentationInput.SegmentationMethod partitionMethod = SegmentationInput.SegmentationMethod.Wavelets;
string parameterconfigPath = Path.Combine(Isas.Framework.Utilities.Utilities.GetAssemblyFolder(typeof(CanvasPartition)), "CanvasPartitionParameters.json");
string ploidyVcfPath = null;
OptionSet p = new OptionSet()
{
{ "i|infile=", "input file - usually generated by CanvasClean", v => cleanedFiles.Add(v) },
{ "v|vaffile=", "variant frequencyfiles - usually generated by CanvasSNV", v => vafFiles.Add(v) },
{ "o|outfile=", "text file to output", v => outPartitionedFiles.Add(v) },
{ "m|method=", "segmentation method (Wavelets/CBS). Default: " + partitionMethod, v => partitionMethod = (SegmentationInput.SegmentationMethod)Enum.Parse(typeof(SegmentationInput.SegmentationMethod), v) },
{ "r|reference=", "folder that contains both genome.fa and GenomeSize.xml", v => referenceFolder = v },
{ "s|split=", "CBS split method (None/Prune/SDUndo). Default: " + undoMethod, v => undoMethod = (SegmentSplitUndo)Enum.Parse(typeof(SegmentSplitUndo), v) },
{ "b|bedfile=", "bed file to exclude (don't span these intervals)", v => filterBedFile = v },
{ "c|commoncnvs=", "bed file with common CNVs (always include these intervals into segmentation results)", v => commonCNVsbedPath = v },
{ "g|germline", "flag indicating that input file represents germline genome", v => isGermline = v != null },
{ $"{CommandLineOptions.EvennessMetricFile}=", "output file for evenness metric (optional)", v => evennessMetricFile = v },
{ "p|ploidyVcfFile=", "vcf file specifying reference ploidy (e.g. for sex chromosomes) (optional)", v => ploidyVcfPath = v },
{ "config=", "parameter configuration path (default {parameterconfigPath})", v => parameterconfigPath = v },
{ "h|help", "show this message and exit", v => needHelp = v != null }
};
List <string> extraArgs = p.Parse(args);
if (extraArgs.Any())
{
throw new IlluminaException($"Unknown arguments: {string.Join(",", extraArgs)}");
}
if (needHelp)
{
ShowHelp(p);
return(0);
}
if (!cleanedFiles.Any() || !outPartitionedFiles.Any() || referenceFolder == null)
{
ShowHelp(p);
return(0);
}
if (cleanedFiles.Any(inFile => !File.Exists(inFile)))
{
Console.WriteLine("CanvasPartition.exe: File {0} does not exist! Exiting.", cleanedFiles);
return(1);
}
if (!string.IsNullOrEmpty(filterBedFile) && !File.Exists(filterBedFile))
{
Console.WriteLine("CanvasPartition.exe: File {0} does not exist! Exiting.", filterBedFile);
return(1);
}
if (!File.Exists(parameterconfigPath))
{
Console.WriteLine($"CanvasPedigreeCaller.exe: File {parameterconfigPath} does not exist! Exiting.");
return(1);
}
if (!string.IsNullOrEmpty(ploidyVcfPath) && !File.Exists(ploidyVcfPath))
{
Console.WriteLine("CanvasPartition.exe: File {0} does not exist! Exiting.", ploidyVcfPath);
return(1);
}
var parameterconfigFile = new FileLocation(parameterconfigPath);
var canvasPartitionParameters = Deserialize <CanvasPartitionParameters>(parameterconfigFile);
ILogger logger = new Logger(Console.Out.ToEnumerable(), Console.Error.ToEnumerable());
var processor = new SegmentationResultsProcessor(canvasPartitionParameters.MaxInterBinDistInSegment);
var segmentationInputs = vafFiles.Count > 0 && vafFiles.Count == cleanedFiles.Count ?
cleanedFiles.Zip(vafFiles, (inFile, vafFile) => new SegmentationInput(inFile, vafFile, filterBedFile,
referenceFolder, evennessMetricFile, logger, processor)).ToList() :
cleanedFiles.Select(inFile => new SegmentationInput(inFile, null, filterBedFile,
referenceFolder, evennessMetricFile, logger, processor)).ToList();
GenomeSegmentationResults segmentationResults;
PloidyInfo referencePloidy = ploidyVcfPath != null?PloidyInfo.LoadPloidyFromVcfFileNoSampleId(ploidyVcfPath) : null;
switch (partitionMethod)
{
default: // use Wavelets if CBS is not selected
Console.WriteLine("{0} Running Wavelet Partitioning", DateTime.Now);
var waveletsRunner = new WaveletsRunner(new WaveletsRunner.WaveletsRunnerParams(isGermline,
commonCNVsbedPath, madFactor:
canvasPartitionParameters.MadFactor,
thresholdLowerMaf: canvasPartitionParameters.ThresholdLowerMaf,
evennessScoreThreshold: canvasPartitionParameters.EvennessScoreThreshold, verbose: 2));
segmentationResults = new GenomeSegmentationResults(waveletsRunner.Run(segmentationInputs.Single(),
canvasPartitionParameters.EvennessScoreWindow));
PostProcessAndWriteResults(segmentationInputs.Single(), outPartitionedFiles.Single(), referencePloidy, segmentationResults);
break;
case SegmentationInput.SegmentationMethod.CBS:
{
Console.WriteLine("{0} Running CBS Partitioning", DateTime.Now);
var cbsRunner = new CBSRunner(canvasPartitionParameters.MaxInterBinDistInSegment, undoMethod,
canvasPartitionParameters.CBSalpha);
var sampleSegmentations = new List <GenomeSegmentationResults>();
foreach (var input in segmentationInputs)
{
var segmentation = new GenomeSegmentationResults(cbsRunner.Run(input, verbose: 2));
sampleSegmentations.Add(segmentation);
}
segmentationResults = GenomeSegmentationResults.SplitOverlappingSegments(sampleSegmentations);
foreach (var(segmentationInput, outPartitionedFile) in segmentationInputs.Zip(outPartitionedFiles))
{
PostProcessAndWriteResults(segmentationInput, outPartitionedFile, referencePloidy, segmentationResults);
}
break;
}
case SegmentationInput.SegmentationMethod.HMM:
{
Console.WriteLine("{0} Running HMM Partitioning", DateTime.Now);
var hiddenMarkovModelsRunner = new HiddenMarkovModelsRunner(cleanedFiles.Count);
bool isPerSample = false;
segmentationResults =
new GenomeSegmentationResults(hiddenMarkovModelsRunner.Run(segmentationInputs, isPerSample));
for (int i = 0; i < segmentationInputs.Count; i++)
{
PostProcessAndWriteResults(segmentationInputs[i], outPartitionedFiles[i], referencePloidy, segmentationResults);
}
break;
}
case SegmentationInput.SegmentationMethod.PerSampleHMM:
{
Console.WriteLine("{0} Running Per-sample HMM Partitioning", DateTime.Now);
var hiddenMarkovModelsRunner = new HiddenMarkovModelsRunner(1);
var sampleSegmentations = new List <GenomeSegmentationResults>();
bool isPerSample = true;
foreach (var input in segmentationInputs)
{
var segmentation =
new GenomeSegmentationResults(
hiddenMarkovModelsRunner.Run(input.Yield().ToList(), isPerSample));
sampleSegmentations.Add(segmentation);
}
segmentationResults = GenomeSegmentationResults.SplitOverlappingSegments(sampleSegmentations);
foreach (var(segmentationInput, outPartitionedFile) in segmentationInputs.Zip(outPartitionedFiles))
{
PostProcessAndWriteResults(segmentationInput, outPartitionedFile, referencePloidy,
segmentationResults);
}
break;
}
}
Console.WriteLine("{0} CanvasPartition results written out", DateTime.Now);
return(0);
}
