public IEnumerator LoadSceneResource(IInfoData infoData,
IResourceManager.LoadBundleFinish delFinish,
object param1,
object param2)
{
yield return(sceneBundleManager.LoadResource(infoData, delFinish, param1, param2));
}
public IVariant[] CreateVariants(IChromosome chromosome, int start, int end, string refAllele,
string[] altAlleles, IInfoData infoData, bool[] isDecomposed, bool isRecomposed, List <string>[] linkedVids, string globalMajorAllele)
{
string firstAltAllele = altAlleles[0];
bool isReference = globalMajorAllele != null;
bool isSymbolicAllele = IsSymbolicAllele(firstAltAllele);
var variantCategory = GetVariantCategory(firstAltAllele, isReference, isSymbolicAllele, infoData.SvType);
if (isReference)
{
return new[] { GetVariant(chromosome, start, end, refAllele, firstAltAllele, infoData, variantCategory, isDecomposed[0], isRecomposed, linkedVids?[0]?.ToArray(), globalMajorAllele) }
}
;
_sequenceProvider.LoadChromosome(chromosome);
var variants = new List <IVariant>();
for (var i = 0; i < altAlleles.Length; i++)
{
#if (!NI_ALLELE)
if (VcfCommon.IsNonInformativeAltAllele(altAlleles[i]))
{
continue;
}
#endif
bool isDecomposedVar = isDecomposed[i];
(int shiftedStart, string shiftedRef, string shiftedAlt) =
VariantUtils.TrimAndLeftAlign(start, refAllele, altAlleles[i], _sequenceProvider.Sequence);
variants.Add(GetVariant(chromosome, shiftedStart, end - (start - shiftedStart), shiftedRef, shiftedAlt, infoData, variantCategory, isDecomposedVar, isRecomposed, linkedVids?[i]?.ToArray(), null));
}
return(variants.Count == 0 ? null : variants.ToArray());
}
private IVariant GetVariant(IChromosome chromosome, int start, int end, string refAllele, string altAllele,
IInfoData infoData, VariantCategory category, bool isDecomposedVar, bool isRecomposed, string[] linkedVids, string globalMajorAllele)
{
switch (category)
{
case VariantCategory.Reference:
return(ReferenceVariantCreator.Create(chromosome, start, end, refAllele, altAllele, globalMajorAllele));
case VariantCategory.SmallVariant:
return(SmallVariantCreator.Create(chromosome, start, refAllele, altAllele, isDecomposedVar, isRecomposed, linkedVids));
case VariantCategory.ROH:
return(RohVariantCreator.Create(chromosome, start, refAllele, altAllele, infoData));
case VariantCategory.SV:
var svBreakEnds = infoData.SvType == VariantType.translocation_breakend ?
GetTranslocationBreakends(chromosome, refAllele, altAllele, start)
: GetSvBreakEnds(chromosome.EnsemblName, start, infoData.SvType, infoData.End);
return(StructuralVariantCreator.Create(chromosome, start, refAllele, altAllele, svBreakEnds, infoData));
case VariantCategory.CNV:
return(CnvCreator.Create(chromosome, start, refAllele, altAllele, infoData));
case VariantCategory.RepeatExpansion:
return(RepeatExpansionCreator.Create(chromosome, start, refAllele, altAllele, infoData));
default:
throw new NotImplementedException("Unrecognized variant category.");
}
}
private IVariant GetVariant(IChromosome chromosome, int start, int end, string refAllele, string altAllele,
IInfoData infoData, VariantCategory category, bool isDecomposed, bool isRecomposed, string[] linkedVids)
{
string vid = _vidCreator.Create(_sequence, category, infoData.SvType, chromosome, start, end, refAllele, altAllele, infoData.RepeatUnit);
int svEnd = infoData.End ?? start;
// ReSharper disable once SwitchStatementMissingSomeCases
switch (category)
{
case VariantCategory.SmallVariant:
return(SmallVariantCreator.Create(chromosome, start, end, refAllele, altAllele, isDecomposed, isRecomposed, linkedVids, vid,
false));
case VariantCategory.ROH:
return(RohVariantCreator.Create(chromosome, start, svEnd, refAllele, altAllele, vid));
case VariantCategory.SV:
return(StructuralVariantCreator.Create(chromosome, start, svEnd, refAllele, altAllele, infoData.SvType, vid));
case VariantCategory.CNV:
return(CnvCreator.Create(chromosome, start, svEnd, refAllele, altAllele, vid));
case VariantCategory.RepeatExpansion:
return(RepeatExpansionCreator.Create(chromosome, start, svEnd, refAllele, altAllele, infoData.RefRepeatCount, vid));
default:
throw new NotImplementedException($"Unrecognized variant category: {category}");
}
}
void DoLoadResource(IInfoData iData, GameObject loadObj, object fun, object param)
{
ModelInfoData infoData = iData as ModelInfoData;
if (infoData == null)
{
return;
}
Debug.Log("DoLoadResource:" + infoData.name);
ClientCha clientCha = param as ClientCha;
if (clientCha == null)
{
return;
}
GameObject newModelObj = GameObject.Instantiate(loadObj, clientCha.transform) as GameObject;
if (newModelObj == null)
{
return;
}
}
public override IEnumerator LoadResource(IInfoData iData, LoadBundleFinish delFinish, object param1, object param2)
{
UIInfoData infoData = iData as UIInfoData;
if (infoData == null)
{
yield break;
}
#if UNITY_EDITOR
if (PlayerSetting.SimulateAssetBundleInEditor)
{
string assertMainPath = GetBundleLoadUrl(infoData.path, infoData.name + ".prefab");
GameObject objectRet = AssetDatabase.LoadAssetAtPath <GameObject>(assertMainPath);
if (objectRet == null)
{
Debug.Log(infoData.name);
}
delFinish(infoData, objectRet, param1, param2);
yield break;
}
#endif
yield return(LoadManifest());
yield return(LoadCommonUI());
string bundleName = infoData.GetBundleName().ToLower();
yield return(LoadPrefabUI(bundleName, true, true));
yield return(LoadGameObject(bundleName, infoData, delFinish, param1, param2));
yield return(null);
}
private static int ExtractEnd(IInfoData infoData, int start, int refAlleleLength)
{
if (infoData.End != null)
{
return(infoData.End.Value);
}
return(start + refAlleleLength - 1);
}
void DoLoadUIItem(IInfoData iData, GameObject curItem, object fun, object param)
{
UIInfoData uiData = iData as UIInfoData;
if (null != fun)
{
OnLoadUIItemDelegate delLoadItem = fun as OnLoadUIItemDelegate;
delLoadItem(curItem, param);
}
}
public override IEnumerator LoadResource(IInfoData iData, LoadBundleFinish delFinish, object param1, object param2)
{
ModelInfoData infoData = iData as ModelInfoData;
if (infoData == null)
{
yield break;
}
#if UNITY_EDITOR
if (PlayerSetting.SimulateAssetBundleInEditor)
{
if (null != delFinish)
{
string assetPath = GetBundleLoadUrl(PathModelPrefab, infoData.name.ToLower(), ".prefab");
GameObject gb = AssetDatabase.LoadAssetAtPath <GameObject>(assetPath);
delFinish(infoData, gb, param1, param2);
}
yield break;
}
#endif
///这里充当加载标识的作用，表示如果当前已经在加载这个资源了，则等待直到资源加载完成
while (m_dicSingleBundleRef.Contains(infoData.GetBundleName()))
{
yield return(0);
}
///添加对应的引用计数
if (!m_dicSingleBundleRef.Contains(infoData.GetBundleName()))
{
m_dicSingleBundleRef.Add(infoData.GetBundleName());
}
if (LoadFromCache(infoData, delFinish, param1, param2))
{
yield break;
}
string assetBundleName = infoData.name.ToLower();
string loadPath = GetBundleLoadUrl(PathModelPrefab, assetBundleName, m_bundleExt);
AssetBundleCreateRequest req = GetBundleRequest(loadPath);
yield return(req);
yield return(ProcessLoad(req.assetBundle, infoData, delFinish, param1, param2));
}
public Position(IChromosome chromosome, int start, int end, string refAllele, string[] altAlleles,
double?quality, string[] filters, IVariant[] variants, ISample[] samples, IInfoData infoData,
string[] vcfFields, bool[] isDecomposed, bool isRecomposed)
{
Chromosome = chromosome;
Start = start;
End = end;
RefAllele = refAllele;
AltAlleles = altAlleles;
Quality = quality;
Filters = filters;
Variants = variants;
Samples = samples;
InfoData = infoData;
VcfFields = vcfFields;
IsDecomposed = isDecomposed;
IsRecomposed = isRecomposed;
}
public IVariant[] CreateVariants(IChromosome chromosome, int start, int end, string refAllele,
string[] altAlleles, IInfoData infoData, bool[] isDecomposedByAllele, bool isRecomposed, List <string>[] linkedVids, string globalMajorAllele)
{
bool isReference = globalMajorAllele != null;
if (isReference)
{
return(ReferenceVariantCreator.Create(_vidCreator, _sequence, chromosome, start, end, refAllele, altAlleles[0], globalMajorAllele));
}
var variantCategory = GetVariantCategory(altAlleles[0], infoData.SvType);
var variants = new List <IVariant>(altAlleles.Length);
for (var i = 0; i < altAlleles.Length; i++)
{
#if (!NI_ALLELE)
if (VcfCommon.IsNonInformativeAltAllele(altAlleles[i]))
{
continue;
}
#endif
string altAllele = altAlleles[i];
bool isDecomposed = isDecomposedByAllele[i];
if (isDecomposed && isRecomposed)
{
throw new InvalidDataException("A variant can't be both decomposed and recomposed");
}
(int shiftedStart, string shiftedRef, string shiftedAlt) =
VariantUtils.TrimAndLeftAlign(start, refAllele, altAllele, _sequence);
if (variantCategory == VariantCategory.SmallVariant || variantCategory == VariantCategory.Reference)
{
end = shiftedStart + shiftedRef.Length - 1;
}
variants.Add(GetVariant(chromosome, shiftedStart, end, shiftedRef, shiftedAlt, infoData, variantCategory,
isDecomposed, isRecomposed, linkedVids?[i]?.ToArray()));
}
return(variants.Count == 0 ? null : variants.ToArray());
}
public static IVariant Create(IChromosome chromosome, int start, string refAllele, string altAllele,
IBreakEnd[] breakEnds, IInfoData infoData, bool enableVerboseTranscript)
{
var svType = infoData?.SvType ?? VariantType.unknown;
if (svType == VariantType.duplication && altAllele == TandemDuplicationAltAllele)
{
svType = VariantType.tandem_duplication;
}
if (svType != VariantType.translocation_breakend)
{
start++;
}
var end = infoData?.End ?? start;
var vid = GetVid(chromosome.EnsemblName, start, end, svType, breakEnds);
return(new Variant(chromosome, start, end, refAllele, altAllele, svType, vid, false, false, false, null,
breakEnds, enableVerboseTranscript ? VerbosedStructuralVariantBehavior : StructuralVariantBehavior));
}
void DoAddUI(IInfoData iData, GameObject curWindow, object fun, object param)
{
UIInfoData uiData = iData as UIInfoData;
Debug.Log("DoAddUI:" + uiData.name);
if (!m_dicWaitLoad.Remove(uiData.name))
{
DestroyBundle(uiData.name);
return;
}
UILayer.ShowUIResult showUIResult = UILayerManager.Instance.ShowUI(uiData, curWindow);
if (showUIResult != UILayer.ShowUIResult.ErrorNotShowed)
{
if (null != fun)
{
OnOpenUIDelegate delOpenUI = fun as OnOpenUIDelegate;
delOpenUI(curWindow != null, param);
}
}
}
public static IVariant Create(IChromosome chromosome, int start, string refAllele, string altAllele, IInfoData infoData)
{
start++;//for the padding base
if (infoData.RefRepeatCount == 0)
{
return(null);
}
(int repeatCount, bool foundError) = altAllele.Trim('<', '>').Substring(3).OptimizedParseInt32();
if (foundError)
{
return(null);
}
if (infoData.RefRepeatCount != null)
{
var svType = GetRepeatExpansionType(infoData.RefRepeatCount.Value, repeatCount);
int end = infoData.End ?? 0;
string vid = GetVid(chromosome.EnsemblName, start, end, infoData.RepeatUnit, repeatCount);
return(new Variant(chromosome, start, end, refAllele, altAllele, svType, vid, false, false, false, null,
null, AnnotationBehavior.RepeatExpansionBehavior));
}
return(null);
}
private IVariant GetVariant(IChromosome chromosome, string id, int start, int end, string refAllele, string altAllele, IInfoData infoData, VariantCategory category, bool isDecomposedVar, bool isRecomposed)
{
switch (category)
{
case VariantCategory.Reference:
var refMinorGlobalMajorAllele = _refMinorProvider?.GetGlobalMajorAlleleForRefMinor(chromosome, start);
return(ReferenceVariantCreator.Create(chromosome, start, end, refAllele, altAllele, refMinorGlobalMajorAllele));
case VariantCategory.SmallVariant:
return(SmallVariantCreator.Create(chromosome, start, refAllele, altAllele, isDecomposedVar, isRecomposed));
case VariantCategory.SV:
var svBreakEnds = infoData.SvType == VariantType.translocation_breakend ?
GetTranslocationBreakends(chromosome, refAllele, altAllele, start)
: GetSvBreakEnds(chromosome.EnsemblName, start, infoData.SvType, infoData.End, infoData.IsInv3, infoData.IsInv5);
return(StructuralVariantCreator.Create(chromosome, start, refAllele, altAllele, svBreakEnds, infoData, _enableVerboseTranscript));
case VariantCategory.CNV:
return(CnvCreator.Create(chromosome, id, start, refAllele, altAllele, infoData, _enableVerboseTranscript));
case VariantCategory.RepeatExpansion:
return(RepeatExpansionCreator.Create(chromosome, start, refAllele, altAllele, infoData));
default:
throw new NotImplementedException("Unrecognized variant category.");
}
}
public IVariant[] CreateVariants(IChromosome chromosome, string id, int start, int end, string refAllele, string[] altAlleles, IInfoData infoData, bool[] isDecomposed, bool isRecomposed)
{
var isReference = altAlleles.Length == 1 && VcfCommon.ReferenceAltAllele.Contains(altAlleles[0]);
var isSymbolicAllele = altAlleles.Any(IsSymbolicAllele);
var variantCategory = GetVariantCategory(altAlleles, isReference, isSymbolicAllele, infoData.SvType);
if (isReference)
{
return new[] { GetVariant(chromosome, id, start, end, refAllele, altAlleles[0], infoData, variantCategory, isDecomposed[0], isRecomposed) }
}
;
var variants = new List <IVariant>();
// ReSharper disable once LoopCanBeConvertedToQuery
for (int i = 0; i < altAlleles.Length; i++)
{
string altAllele = altAlleles[i];
bool isDecomposedVar = isDecomposed[i];
if (VcfCommon.NonInformativeAltAllele.Contains(altAllele))
{
continue;
}
variants.Add(GetVariant(chromosome, id, start, end, refAllele, altAllele, infoData, variantCategory, isDecomposedVar, isRecomposed));
}
return(variants.Count == 0 ? null : variants.ToArray());
}
public abstract IEnumerator LoadResource(IInfoData infoData,
LoadBundleFinish delFinish,
object param1,
object param2);
public static IVariant Create(IChromosome chromosome, int start, string refAllele, string altAllele, IInfoData infoData)
{
start++;
int end = infoData?.End ?? start;
if (altAllele != "<ROH>")
{
throw new ArgumentException("The only allowed ALT allele is <ROH>.");
}
string vid = $"{chromosome.EnsemblName}:{start}:{end}:ROH";
return(CreateRohVariant(chromosome, start, end, refAllele, altAllele, vid));
}
public static IVariant Create(IChromosome chromosome, string id, int start, string refAllele, string altAllele, IInfoData infoData, bool enableVerboseTranscript)
{
start++;
// CNV caller's can use <DUP> to indicate a copy number increase where the exact copy number is unknown
if (altAllele == "<DUP>")
{
var dupEnd = infoData.End ?? start;
var dupVid = $"{chromosome.EnsemblName}:{start}:{dupEnd}:DUP";
return(new Variant(chromosome, start, dupEnd, refAllele, altAllele, VariantType.copy_number_gain, dupVid, false, false, false, null, null, enableVerboseTranscript ? VerbosedCnvBehavior : CnvBehavior));
}
var copyNumber = GetCopyNumber(altAllele);
var svType = GetType(copyNumber);
var end = infoData.End ?? start;
var vid = GetVid(chromosome.EnsemblName, start, end, copyNumber);
return(new Variant(chromosome, start, end, refAllele, altAllele, svType, vid, false, false, false, null, null, enableVerboseTranscript ? VerbosedCnvBehavior : CnvBehavior));
}
public static IVariant Create(IChromosome chromosome, int start, string refAllele, string altAllele, IInfoData infoData)
{
start++;
int end = infoData.End ?? start;
string vid;
switch (altAllele)
{
case "<CNV>":
vid = $"{chromosome.EnsemblName}:{start}:{end}:CNV";
return(CreateCNV(chromosome, start, end, refAllele, altAllele, VariantType.copy_number_variation, vid));
case "<DEL>":
vid = $"{chromosome.EnsemblName}:{start}:{end}:CDEL";
return(CreateCNV(chromosome, start, end, refAllele, altAllele, VariantType.copy_number_loss, vid));
case "<DUP>":
vid = $"{chromosome.EnsemblName}:{start}:{end}:CDUP";
return(CreateCNV(chromosome, start, end, refAllele, altAllele, VariantType.copy_number_gain, vid));
}
// the remaining cases are either <CNV> or <CN1>, <CN4>, etc.
// do not try to determine the overall copy number gain or loss
// - for allele-specific you'll probably introduce inconsistency
// - for normal <CNV>, you'll probably get type wrong for MT, sex chromosomes, etc.
string trimmedAltAllele = altAllele.Substring(1, altAllele.Length - 2);
vid = $"{chromosome.EnsemblName}:{start}:{end}:{trimmedAltAllele}";
return(CreateCNV(chromosome, start, end, refAllele, altAllele, VariantType.copy_number_variation, vid));
}
public static IVariant Create(IChromosome chromosome, int start, string refAllele, string altAllele, IInfoData infoData)
{
start++; //for the padding base
if (infoData.RefRepeatCount == 0)
{
return(null);
}
var repeatCount = int.Parse(altAllele.Trim('<', '>').Substring(3));
var svType = repeatCount == infoData.RefRepeatCount ? VariantType.short_tandem_repeat_variation:
repeatCount > infoData.RefRepeatCount
? VariantType.short_tandem_repeat_expansion
: VariantType.short_tandem_repeat_contraction;
var end = infoData.End ?? 0;
var vid = GetVid(chromosome.EnsemblName, start, end, infoData.RepeatUnit, repeatCount);
return(new Variant(chromosome, start, end, refAllele, altAllele, svType, vid, false, false, false, null, null, RepeatExpansionBehavior));
}
