badData;
+
/**
- * Constructor given an alignment context
+ * Constructor given a VCF file
*
* @param alignment
*/
- public VCFLoader(AlignmentI alignment)
+ public VCFLoader(String vcfFile)
{
- al = alignment;
+ try
+ {
+ initialise(vcfFile);
+ } catch (IOException e)
+ {
+ System.err.println("Error opening VCF file: " + e.getMessage());
+ }
// map of species!chromosome!fromAssembly!toAssembly to {fromRange, toRange}
assemblyMappings = new HashMap<>();
}
/**
- * Starts a new thread to query and load VCF variant data on to the alignment
+ * Starts a new thread to query and load VCF variant data on to the given
+ * sequences
*
* This method is not thread safe - concurrent threads should use separate
* instances of this class.
*
- * @param filePath
+ * @param seqs
* @param gui
*/
- public void loadVCF(final String filePath,
- final AlignViewControllerGuiI gui)
+ public void loadVCF(SequenceI[] seqs, final AlignViewControllerGuiI gui)
{
if (gui != null)
{
@@ -220,54 +294,70 @@ public class VCFLoader
new Thread()
{
-
@Override
public void run()
{
- VCFLoader.this.doLoad(filePath, gui);
+ VCFLoader.this.doLoad(seqs, gui);
}
-
}.start();
}
/**
- * Loads VCF on to an alignment - provided it can be related to one or more
- * sequence's chromosomal coordinates
+ * Reads the specified contig sequence and adds its VCF variants to it
*
- * @param filePath
- * @param gui
- * optional callback handler for messages
+ * @param contig
+ * the id of a single sequence (contig) to load
+ * @return
*/
- protected void doLoad(String filePath, AlignViewControllerGuiI gui)
+ public SequenceI loadVCFContig(String contig)
{
- VCFReader reader = null;
- try
+ VCFHeaderLine headerLine = header.getOtherHeaderLine(VCFHeader.REFERENCE_KEY);
+ if (headerLine == null)
{
- // long start = System.currentTimeMillis();
- reader = new VCFReader(filePath);
-
- header = reader.getFileHeader();
-
- try
- {
- dictionary = header.getSequenceDictionary();
- } catch (SAMException e)
- {
- // ignore - thrown if any contig line lacks length info
- }
+ Cache.log.error("VCF reference header not found");
+ return null;
+ }
+ String ref = headerLine.getValue();
+ if (ref.startsWith("file://"))
+ {
+ ref = ref.substring(7);
+ }
+ setSpeciesAndAssembly(ref);
- sourceId = filePath;
+ SequenceI seq = null;
+ File dbFile = new File(ref);
- saveMetadata(sourceId);
+ if (dbFile.exists())
+ {
+ HtsContigDb db = new HtsContigDb("", dbFile);
+ seq = db.getSequenceProxy(contig);
+ loadSequenceVCF(seq);
+ db.close();
+ }
+ else
+ {
+ Cache.log.error("VCF reference not found: " + ref);
+ }
- /*
- * get offset of CSQ ALLELE_NUM and Feature if declared
- */
- parseCsqHeader();
+ return seq;
+ }
+ /**
+ * Loads VCF on to one or more sequences
+ *
+ * @param seqs
+ * @param gui
+ * optional callback handler for messages
+ */
+ protected void doLoad(SequenceI[] seqs, AlignViewControllerGuiI gui)
+ {
+ try
+ {
VCFHeaderLine ref = header
.getOtherHeaderLine(VCFHeader.REFERENCE_KEY);
- String vcfAssembly = ref.getValue();
+ String reference = ref == null ? null : ref.getValue();
+
+ setSpeciesAndAssembly(reference);
int varCount = 0;
int seqCount = 0;
@@ -275,9 +365,9 @@ public class VCFLoader
/*
* query for VCF overlapping each sequence in turn
*/
- for (SequenceI seq : al.getSequences())
+ for (SequenceI seq : seqs)
{
- int added = loadSequenceVCF(seq, reader, vcfAssembly);
+ int added = loadSequenceVCF(seq);
if (added > 0)
{
seqCount++;
@@ -287,7 +377,6 @@ public class VCFLoader
}
if (gui != null)
{
- // long elapsed = System.currentTimeMillis() - start;
String msg = MessageManager.formatMessage("label.added_vcf",
varCount, seqCount);
gui.setStatus(msg);
@@ -322,6 +411,103 @@ public class VCFLoader
}
/**
+ * Attempts to determine and save the species and genome assembly version to
+ * which the VCF data applies. This may be done by parsing the {@code reference}
+ * header line, configured in a property file, or (potentially) confirmed
+ * interactively by the user.
+ *
+ * The saved values should be identifiers valid for Ensembl's REST service
+ * {@code map} endpoint, so they can be used (if necessary) to retrieve the
+ * mapping between VCF coordinates and sequence coordinates.
+ *
+ * @param reference
+ * @see https://rest.ensembl.org/documentation/info/assembly_map
+ * @see https://rest.ensembl.org/info/assembly/human?content-type=text/xml
+ * @see https://rest.ensembl.org/info/species?content-type=text/xml
+ */
+ protected void setSpeciesAndAssembly(String reference)
+ {
+ if (reference == null)
+ {
+ Cache.log.error("No VCF ##reference found, defaulting to "
+ + DEFAULT_REFERENCE + ":" + DEFAULT_SPECIES);
+ reference = DEFAULT_REFERENCE; // default to GRCh37 if not specified
+ }
+ reference = reference.toLowerCase(Locale.ROOT);
+
+ /*
+ * for a non-human species, or other assembly identifier,
+ * specify as a Jalview property file entry e.g.
+ * VCF_ASSEMBLY = hs37=GRCh37,assembly19=GRCh37
+ * VCF_SPECIES = c_elegans=celegans
+ * to map a token in the reference header to a value
+ */
+ String prop = Cache.getDefault(VCF_ASSEMBLY, DEFAULT_VCF_ASSEMBLY);
+ for (String token : prop.split(","))
+ {
+ String[] tokens = token.split("=");
+ if (tokens.length == 2)
+ {
+ if (reference.contains(tokens[0].trim().toLowerCase(Locale.ROOT)))
+ {
+ vcfAssembly = tokens[1].trim();
+ break;
+ }
+ }
+ }
+
+ vcfSpecies = DEFAULT_SPECIES;
+ prop = Cache.getProperty(VCF_SPECIES);
+ if (prop != null)
+ {
+ for (String token : prop.split(","))
+ {
+ String[] tokens = token.split("=");
+ if (tokens.length == 2)
+ {
+ if (reference.contains(tokens[0].trim().toLowerCase(Locale.ROOT)))
+ {
+ vcfSpecies = tokens[1].trim();
+ break;
+ }
+ }
+ }
+ }
+ }
+
+ /**
+ * Opens the VCF file and parses header data
+ *
+ * @param filePath
+ * @throws IOException
+ */
+ private void initialise(String filePath) throws IOException
+ {
+ vcfFilePath = filePath;
+
+ reader = new VCFReader(filePath);
+
+ header = reader.getFileHeader();
+
+ try
+ {
+ dictionary = header.getSequenceDictionary();
+ } catch (SAMException e)
+ {
+ // ignore - thrown if any contig line lacks length info
+ }
+
+ sourceId = filePath;
+
+ saveMetadata(sourceId);
+
+ /*
+ * get offset of CSQ ALLELE_NUM and Feature if declared
+ */
+ parseCsqHeader();
+ }
+
+ /**
* Reads metadata (such as INFO field descriptions and datatypes) and saves
* them for future reference
*
@@ -384,7 +570,7 @@ public class VCFLoader
{
for (Pattern p : filters)
{
- if (p.matcher(id.toUpperCase()).matches())
+ if (p.matcher(id.toUpperCase(Locale.ROOT)).matches())
{
return true;
}
@@ -478,7 +664,7 @@ public class VCFLoader
{
try
{
- patterns.add(Pattern.compile(token.toUpperCase()));
+ patterns.add(Pattern.compile(token.toUpperCase(Locale.ROOT)));
} catch (PatternSyntaxException e)
{
System.err.println("Invalid pattern ignored: " + token);
@@ -489,13 +675,12 @@ public class VCFLoader
/**
* Transfers VCF features to sequences to which this sequence has a mapping.
- * If the mapping is 3:1, computes peptide variants from nucleotide variants.
*
* @param seq
*/
protected void transferAddedFeatures(SequenceI seq)
{
- DBRefEntry[] dbrefs = seq.getDBRefs();
+ List dbrefs = seq.getDBRefs();
if (dbrefs == null)
{
return;
@@ -515,7 +700,8 @@ public class VCFLoader
/*
* dna-to-peptide product mapping
*/
- AlignmentUtils.computeProteinFeatures(seq, mapTo, map);
+ // JAL-3187 render on the fly instead
+ // AlignmentUtils.computeProteinFeatures(seq, mapTo, map);
}
else
{
@@ -536,37 +722,38 @@ public class VCFLoader
}
/**
- * Tries to add overlapping variants read from a VCF file to the given
- * sequence, and returns the number of variant features added. Note that this
- * requires the sequence to hold information as to its species, chromosomal
- * positions and reference assembly, in order to be able to map the VCF
- * variants to the sequence (or not)
+ * Tries to add overlapping variants read from a VCF file to the given sequence,
+ * and returns the number of variant features added
*
* @param seq
- * @param reader
- * @param vcfAssembly
* @return
*/
- protected int loadSequenceVCF(SequenceI seq, VCFReader reader,
- String vcfAssembly)
+ protected int loadSequenceVCF(SequenceI seq)
{
- VCFMap vcfMap = getVcfMap(seq, vcfAssembly);
+ VCFMap vcfMap = getVcfMap(seq);
if (vcfMap == null)
{
return 0;
}
- return addVcfVariants(seq, reader, vcfMap, vcfAssembly);
+ /*
+ * work with the dataset sequence here
+ */
+ SequenceI dss = seq.getDatasetSequence();
+ if (dss == null)
+ {
+ dss = seq;
+ }
+ return addVcfVariants(dss, vcfMap);
}
/**
* Answers a map from sequence coordinates to VCF chromosome ranges
*
* @param seq
- * @param vcfAssembly
* @return
*/
- private VCFMap getVcfMap(SequenceI seq, String vcfAssembly)
+ private VCFMap getVcfMap(SequenceI seq)
{
/*
* simplest case: sequence has id and length matching a VCF contig
@@ -597,34 +784,28 @@ public class VCFLoader
String species = seqCoords.getSpeciesId();
String chromosome = seqCoords.getChromosomeId();
String seqRef = seqCoords.getAssemblyId();
- MapList map = seqCoords.getMap();
+ MapList map = seqCoords.getMapping();
- if (!vcfSpeciesMatchesSequence(vcfAssembly, species))
+ // note this requires the configured species to match that
+ // returned with the Ensembl sequence; todo: support aliases?
+ if (!vcfSpecies.equalsIgnoreCase(species))
{
+ Cache.log.warn("No VCF loaded to " + seq.getName()
+ + " as species not matched");
return null;
}
- if (vcfAssemblyMatchesSequence(vcfAssembly, seqRef))
+ if (seqRef.equalsIgnoreCase(vcfAssembly))
{
return new VCFMap(chromosome, map);
}
- if (!"GRCh38".equalsIgnoreCase(seqRef) // Ensembl
- || !vcfAssembly.contains("Homo_sapiens_assembly19")) // gnomAD
- {
- return null;
- }
-
/*
- * map chromosomal coordinates from sequence to VCF if the VCF
- * data has a different reference assembly to the sequence
+ * VCF data has a different reference assembly to the sequence:
+ * query Ensembl to map chromosomal coordinates from sequence to VCF
*/
- // TODO generalise for cases other than GRCh38 -> GRCh37 !
- // - or get the user to choose in a dialog
-
List toVcfRanges = new ArrayList<>();
List fromSequenceRanges = new ArrayList<>();
- String toRef = "GRCh37";
for (int[] range : map.getToRanges())
{
@@ -636,12 +817,13 @@ public class VCFLoader
}
int[] newRange = mapReferenceRange(range, chromosome, "human", seqRef,
- toRef);
+ vcfAssembly);
if (newRange == null)
{
Cache.log.error(
String.format("Failed to map %s:%s:%s:%d:%d to %s", species,
- chromosome, seqRef, range[0], range[1], toRef));
+ chromosome, seqRef, range[0], range[1],
+ vcfAssembly));
continue;
}
else
@@ -682,76 +864,16 @@ public class VCFLoader
}
/**
- * Answers true if we determine that the VCF data uses the same reference
- * assembly as the sequence, else false
- *
- * @param vcfAssembly
- * @param seqRef
- * @return
- */
- private boolean vcfAssemblyMatchesSequence(String vcfAssembly,
- String seqRef)
- {
- // TODO improve on this stub, which handles gnomAD and
- // hopes for the best for other cases
-
- if ("GRCh38".equalsIgnoreCase(seqRef) // Ensembl
- && vcfAssembly.contains("Homo_sapiens_assembly19")) // gnomAD
- {
- return false;
- }
- return true;
- }
-
- /**
- * Answers true if the species inferred from the VCF reference identifier
- * matches that for the sequence
- *
- * @param vcfAssembly
- * @param speciesId
- * @return
- */
- boolean vcfSpeciesMatchesSequence(String vcfAssembly, String speciesId)
- {
- // PROBLEM 1
- // there are many aliases for species - how to equate one with another?
- // PROBLEM 2
- // VCF ##reference header is an unstructured URI - how to extract species?
- // perhaps check if ref includes any (Ensembl) alias of speciesId??
- // TODO ask the user to confirm this??
-
- if (vcfAssembly.contains("Homo_sapiens") // gnomAD exome data example
- && "HOMO_SAPIENS".equals(speciesId)) // Ensembl species id
- {
- return true;
- }
-
- if (vcfAssembly.contains("c_elegans") // VEP VCF response example
- && "CAENORHABDITIS_ELEGANS".equals(speciesId)) // Ensembl
- {
- return true;
- }
-
- // this is not a sustainable solution...
-
- return false;
- }
-
- /**
* Queries the VCF reader for any variants that overlap the mapped chromosome
* ranges of the sequence, and adds as variant features. Returns the number of
* overlapping variants found.
*
* @param seq
- * @param reader
* @param map
* mapping from sequence to VCF coordinates
- * @param vcfAssembly
- * the '##reference' identifier for the VCF reference assembly
* @return
*/
- protected int addVcfVariants(SequenceI seq, VCFReader reader,
- VCFMap map, String vcfAssembly)
+ protected int addVcfVariants(SequenceI seq, VCFMap map)
{
boolean forwardStrand = map.map.isToForwardStrand();
@@ -764,54 +886,45 @@ public class VCFLoader
{
int vcfStart = Math.min(range[0], range[1]);
int vcfEnd = Math.max(range[0], range[1]);
- CloseableIterator variants = reader
- .query(map.chromosome, vcfStart, vcfEnd);
- while (variants.hasNext())
+ try
{
- VariantContext variant = variants.next();
-
- int[] featureRange = map.map.locateInFrom(variant.getStart(),
- variant.getEnd());
-
- if (featureRange != null)
+ CloseableIterator variants = reader
+ .query(map.chromosome, vcfStart, vcfEnd);
+ while (variants.hasNext())
{
- int featureStart = Math.min(featureRange[0], featureRange[1]);
- int featureEnd = Math.max(featureRange[0], featureRange[1]);
- count += addAlleleFeatures(seq, variant, featureStart, featureEnd,
- forwardStrand);
- }
- }
- variants.close();
- }
+ VariantContext variant = variants.next();
- return count;
- }
+ int[] featureRange = map.map.locateInFrom(variant.getStart(),
+ variant.getEnd());
- /**
- * A convenience method to get the AF value for the given alternate allele
- * index
- *
- * @param variant
- * @param alleleIndex
- * @return
- */
- protected float getAlleleFrequency(VariantContext variant, int alleleIndex)
- {
- float score = 0f;
- String attributeValue = getAttributeValue(variant,
- ALLELE_FREQUENCY_KEY, alleleIndex);
- if (attributeValue != null)
- {
- try
- {
- score = Float.parseFloat(attributeValue);
- } catch (NumberFormatException e)
+ /*
+ * only take features whose range is fully mappable to sequence positions
+ */
+ if (featureRange != null)
+ {
+ int featureStart = Math.min(featureRange[0], featureRange[1]);
+ int featureEnd = Math.max(featureRange[0], featureRange[1]);
+ if (featureEnd - featureStart == variant.getEnd()
+ - variant.getStart())
+ {
+ count += addAlleleFeatures(seq, variant, featureStart,
+ featureEnd, forwardStrand);
+ }
+ }
+ }
+ variants.close();
+ } catch (TribbleException e)
{
- // leave as 0
+ /*
+ * RuntimeException throwable by htsjdk
+ */
+ String msg = String.format("Error reading VCF for %s:%d-%d: %s ",
+ map.chromosome, vcfStart, vcfEnd,e.getLocalizedMessage());
+ Cache.log.error(msg);
}
}
- return score;
+ return count;
}
/**
@@ -892,10 +1005,24 @@ public class VCFLoader
String allele = alt.getBaseString();
/*
+ * insertion after a genomic base, if on reverse strand, has to be
+ * converted to insertion of complement after the preceding position
+ */
+ int referenceLength = reference.length();
+ if (!forwardStrand && allele.length() > referenceLength
+ && allele.startsWith(reference))
+ {
+ featureStart -= referenceLength;
+ featureEnd = featureStart;
+ char insertAfter = seq.getCharAt(featureStart - seq.getStart());
+ reference = Dna.reverseComplement(String.valueOf(insertAfter));
+ allele = allele.substring(referenceLength) + reference;
+ }
+
+ /*
* build the ref,alt allele description e.g. "G,A", using the base
* complement if the sequence is on the reverse strand
*/
- // FIXME correctly handle insertions on reverse strand JAL-2845
StringBuilder sb = new StringBuilder();
sb.append(forwardStrand ? reference : Dna.reverseComplement(reference));
sb.append(COMMA);
@@ -908,7 +1035,7 @@ public class VCFLoader
*/
String consequence = getConsequenceForAlleleAndFeature(variant, CSQ_FIELD,
altAlleleIndex, csqAlleleFieldIndex,
- csqAlleleNumberFieldIndex, seq.getName().toLowerCase(),
+ csqAlleleNumberFieldIndex, seq.getName().toLowerCase(Locale.ROOT),
csqFeatureFieldIndex);
/*
@@ -917,19 +1044,29 @@ public class VCFLoader
String type = SequenceOntologyI.SEQUENCE_VARIANT;
if (consequence != null)
{
- type = getOntologyTerm(seq, variant, altAlleleIndex,
- consequence);
+ type = getOntologyTerm(consequence);
}
- float score = getAlleleFrequency(variant, altAlleleIndex);
-
SequenceFeature sf = new SequenceFeature(type, alleles, featureStart,
- featureEnd, score, FEATURE_GROUP_VCF);
+ featureEnd, FEATURE_GROUP_VCF);
sf.setSource(sourceId);
- sf.setValue(Gff3Helper.ALLELES, alleles);
+ /*
+ * save the derived alleles as a named attribute; this will be
+ * needed when Jalview computes derived peptide variants
+ */
+ addFeatureAttribute(sf, Gff3Helper.ALLELES, alleles);
- addAlleleProperties(variant, seq, sf, altAlleleIndex, consequence);
+ /*
+ * add selected VCF fixed column data as feature attributes
+ */
+ addFeatureAttribute(sf, VCF_POS, String.valueOf(variant.getStart()));
+ addFeatureAttribute(sf, VCF_ID, variant.getID());
+ addFeatureAttribute(sf, VCF_QUAL,
+ String.valueOf(variant.getPhredScaledQual()));
+ addFeatureAttribute(sf, VCF_FILTER, getFilter(variant));
+
+ addAlleleProperties(variant, sf, altAlleleIndex, consequence);
seq.addSequenceFeature(sf);
@@ -937,6 +1074,53 @@ public class VCFLoader
}
/**
+ * Answers the VCF FILTER value for the variant - or an approximation to it.
+ * This field is either PASS, or a semi-colon separated list of filters not
+ * passed. htsjdk saves filters as a HashSet, so the order when reassembled into
+ * a list may be different.
+ *
+ * @param variant
+ * @return
+ */
+ String getFilter(VariantContext variant)
+ {
+ Set filters = variant.getFilters();
+ if (filters.isEmpty())
+ {
+ return NO_VALUE;
+ }
+ Iterator iterator = filters.iterator();
+ String first = iterator.next();
+ if (filters.size() == 1)
+ {
+ return first;
+ }
+
+ StringBuilder sb = new StringBuilder(first);
+ while (iterator.hasNext())
+ {
+ sb.append(";").append(iterator.next());
+ }
+
+ return sb.toString();
+ }
+
+ /**
+ * Adds one feature attribute unless the value is null, empty or '.'
+ *
+ * @param sf
+ * @param key
+ * @param value
+ */
+ void addFeatureAttribute(SequenceFeature sf, String key, String value)
+ {
+ if (value != null && !value.isEmpty() && !NO_VALUE.equals(value))
+ {
+ sf.setValue(key, value);
+ }
+ }
+
+ /**
* Determines the Sequence Ontology term to use for the variant feature type in
* Jalview. The default is 'sequence_variant', but a more specific term is used
* if:
@@ -945,18 +1129,18 @@ public class VCFLoader
* sequence id can be matched to VEP Feature (or SnpEff Feature_ID)
*