Exemple #1
0
  public void generateTrackFromLocation(int mousePos, boolean isHorizontal) {

    if (!MatrixType.isObservedOrControl(displayOption)) {
      MessageUtils.showMessage("This feature is only available for Observed or Control views");
      return;
    }

    // extract the starting position
    int binStartPosition = (int) (getXContext().getBinOrigin() + mousePos / getScaleFactor());
    if (isHorizontal)
      binStartPosition = (int) (getYContext().getBinOrigin() + mousePos / getScaleFactor());

    // Initialize default file name
    String filename = displayOption == MatrixType.OBSERVED ? "obs" : "ctrl";
    filename += isHorizontal ? "_horz" : "_vert";
    filename += "_bin" + binStartPosition + "_res" + currentZoom.getBinSize();
    filename = cleanUpNumbersInName(filename);

    // allow user to customize or change the name
    filename = MessageUtils.showInputDialog("Enter a name for the resulting .wig file", filename);
    if (filename == null || filename.equalsIgnoreCase("null")) return;

    File outputWigFile = new File(DirectoryManager.getHiCDirectory(), filename + ".wig");
    MessageUtils.showMessage("Data will be saved to " + outputWigFile.getAbsolutePath());

    Chromosome chromosomeForPosition = getXContext().getChromosome();
    if (isHorizontal) chromosomeForPosition = getYContext().getChromosome();

    safeSave1DTrackToWigFile(chromosomeForPosition, outputWigFile, binStartPosition);
  }
Exemple #2
0
  public List<Feature> getFeatures(final String chr) {

    List<Feature> features = featureCache.get(chr);
    if (features == null) {
      final String filename = fileMap.getProperty(chr);
      if (filename != null) {
        BufferedReader reader = null;
        String path = rootDir + "/" + filename;
        try {
          log.info("Loading " + path);
          // Load features here
          ResourceLocator loc = new ResourceLocator(path);

          FeatureParser fp = AbstractFeatureParser.getInstanceFor(loc, genome);
          reader = ParsingUtils.openBufferedReader(loc);
          features = fp.loadFeatures(reader, genome);
          featureCache.put(chr, features);
        } catch (IOException ex) {
          MessageUtils.showMessage("Error loading file: " + path + " (" + ex.toString() + ")");
          log.info("Error loading feature file: " + filename, ex);
        } finally {
          if (reader != null) {
            try {
              reader.close();
            } catch (IOException e) {

            }
          }
        }
      }
    }
    return featureCache.get(chr);
  }
    public void drop(DropTargetDropEvent event) {
      if (!isDropAcceptable(event)) {
        event.rejectDrop();
        return;
      }

      event.acceptDrop(DnDConstants.ACTION_COPY);

      Transferable transferable = event.getTransferable();

      MessageCollection messages = new MessageCollection();
      try {
        List<File> files = (List<File>) transferable.getTransferData(DataFlavor.javaFileListFlavor);

        for (File file : files) {
          try {
            ResourceLocator locator = new ResourceLocator(file.getAbsolutePath());
            IGV.getInstance().load(locator, panel);
          } catch (DataLoadException de) {
            messages.append(de.getMessage());
          }
        }
        String obj = transferable.getTransferData(DataFlavor.stringFlavor).toString();
        if (HttpUtils.isRemoteURL(obj)) {
          IGV.getInstance().load(new ResourceLocator(obj), panel);
        }
        if (messages != null && !messages.isEmpty()) {
          log.error(messages.getFormattedMessage());
          MessageUtils.showMessage(messages.getFormattedMessage());
        }
      } catch (Exception e) {
        String obj = null;
        try {
          obj = transferable.getTransferData(DataFlavor.stringFlavor).toString();
          if (HttpUtils.isRemoteURL(obj)) {
            IGV.getInstance().load(new ResourceLocator(obj), panel);
          }
        } catch (Exception e1) {
          log.error(e1);
          if (messages != null && !messages.isEmpty()) {
            MessageUtils.showMessage(messages.getFormattedMessage());
          }
        }
      }
      IGV.getMainFrame().repaint();
      event.dropComplete(true);
    }
Exemple #4
0
 private void loadGMT(ResourceLocator locator) throws IOException {
   List<GeneList> lists = GeneListManager.getInstance().loadGMTFile(locator.getPath());
   if (lists.size() == 1) {
     GeneList gl = lists.get(0);
     IGV.getInstance().setGeneList(gl, true);
   } else {
     MessageUtils.showMessage("Loaded " + lists.size() + " gene lists.");
   }
 }
  private void extractGeneLocation() {
    GeneLocation location1 = geneLocationHashMap.get(positionChrTop.getText().trim().toLowerCase());
    GeneLocation location2 =
        geneLocationHashMap.get(positionChrLeft.getText().trim().toLowerCase());
    if (location1 == null) {
      positionChrTop.setBackground(Color.yellow);
      MessageUtils.showMessage(
          "Gene location map doesn't contain " + positionChrTop.getText().trim());
      return;
    }
    if (location2 == null) {
      positionChrLeft.setBackground(Color.yellow);
      MessageUtils.showMessage(
          "Gene location map doesn't contain " + positionChrLeft.getText().trim());
      return;
    }

    List<Integer> bpResolutions = Ints.asList(HiCGlobals.bpBinSizes);
    int geneZoomResolution = hic.getZoom().getBinSize();
    if (!bpResolutions.contains(geneZoomResolution)) {
      geneZoomResolution = Collections.min(bpResolutions);
    }

    hic.setLocation(
        location1.chromosome,
        location2.chromosome,
        HiC.Unit.BP,
        geneZoomResolution,
        location1.centerPosition,
        location2.centerPosition,
        hic.getScaleFactor(),
        HiC.ZoomCallType.STANDARD,
        "Gene Goto",
        true);

    superAdapter.setNormalizationDisplayState();
  }
Exemple #6
0
  private void loadGctFile(ResourceLocator locator, List<Track> newTracks, Genome genome)
      throws IOException {

    if (locator.isLocal()) {
      if (!checkSize(locator)) {
        return;
      }
    }

    ExpressionFileParser parser = null;
    ExpressionDataset ds = null;
    parser = new ExpressionFileParser(locator, null, genome);
    ds = parser.createDataset();
    if (ds.isEmpty()) {
      String message =
          "The probes in the file <br>&nbsp;&nbsp;&nbsp;"
              + locator.getPath()
              + "<br>"
              + "could not be mapped to genomic positions.  This can be corrected by specify a probe mapping<br>"
              + "file from the Preferences window (Probes tab), or by specifing the genomic positions in the<br>"
              + "expression data file.  Please see the user guide for more details.";
      MessageUtils.showMessage(message);

    } else {
      ds.setName(locator.getTrackName());
      ds.setNormalized(true);
      ds.setLogValues(true);

      /*
       * File outputFile = new File(IGV.DEFAULT_USER_DIRECTORY, file.getName() + ".h5");
       * OverlappingProcessor proc = new OverlappingProcessor(ds);
       * proc.setZoomMax(0);
       * proc.process(outputFile.getAbsolutePath());
       * loadH5File(outputFile, messages, attributeList, group);
       */

      // Counter for generating ID
      TrackProperties trackProperties = ds.getTrackProperties();
      String path = locator.getPath();
      for (String trackName : ds.getTrackNames()) {
        DatasetDataSource dataSource = new DatasetDataSource(trackName, ds, genome);
        String trackId = path + "_" + trackName;
        Track track = new DataSourceTrack(locator, trackId, trackName, dataSource);
        track.setRendererClass(HeatmapRenderer.class);
        track.setProperties(trackProperties);
        newTracks.add(track);
      }
    }
  }
Exemple #7
0
 /**
  * Compare the sequence names against sequence (chromosome) names in the genome. If no matches
  * warn the user.
  *
  * @param filename
  * @param genome
  * @param seqNames
  * @return true if there is at least one sequence match, false otherwise
  */
 private boolean checkSequenceNames(String filename, Genome genome, List<String> seqNames) {
   boolean atLeastOneMatch = false;
   for (String seqName : seqNames) {
     if (genome.getChromosome(seqName) != null) {
       atLeastOneMatch = true;
       break;
     }
   }
   if (!atLeastOneMatch) {
     StringBuffer message = new StringBuffer();
     message.append(
         "<html>File: "
             + filename
             + "<br>does not contain any sequence names which match the current genome.");
     message.append("<br><br>File: &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;");
     int n = 0;
     for (String sn : seqNames) {
       message.append(sn + ", ");
       n++;
       if (n > 3) {
         message.append(" ...");
         break;
       }
     }
     message.append("<br>Genome: ");
     n = 0;
     for (String cn : genome.getAllChromosomeNames()) {
       message.append(cn + ", ");
       n++;
       if (n > 3) {
         message.append(" ...");
         break;
       }
     }
     MessageUtils.showMessage(message.toString());
   }
   return atLeastOneMatch;
 }
  private void unsafeInitializeGeneHashMap(String genomeID) {
    // Custom format parsed from ref Gene file.
    // Name1 Name2 chromosome position (where position is midpoint of transcription start and end)
    String path = "http://hicfiles.s3.amazonaws.com/internal/" + genomeID + "_refGene.txt";
    BufferedReader reader;
    try {
      SeekableHTTPStream stream = new SeekableHTTPStream(new URL(path));

      reader = new BufferedReader(new InputStreamReader(stream), HiCGlobals.bufferSize);
      MessageUtils.showMessage(
          "Loading gene database for " + genomeID + ".\nIt might take a minute or so. ");
    } catch (Exception error) {
      MessageUtils.showErrorMessage("Failed to read gene database", error);
      positionChrTop.setBackground(Color.yellow);
      geneLocationHashMap = null;
      return;
    }

    geneLocationHashMap = new HashMap<String, GeneLocation>();
    String nextLine;

    try {
      while ((nextLine = reader.readLine()) != null) {
        String[] values = nextLine.split(" ");
        GeneLocation location =
            new GeneLocation(values[2].trim(), Integer.valueOf(values[3].trim()));
        geneLocationHashMap.put(values[0].trim().toLowerCase(), location);
        geneLocationHashMap.put(values[1].trim().toLowerCase(), location);
      }
    } catch (Exception error) {
      MessageUtils.showErrorMessage("Failed to parse gene database", error);
      positionChrTop.setBackground(Color.yellow);
      geneLocationHashMap = null;
    }
    if (geneLocationHashMap != null) this.genomeID = genomeID;
    extractGeneLocation();
  }
Exemple #9
0
  private static ConnectionWrapper connect(String url) {
    try {
      return new ConnectionWrapper(DriverManager.getConnection(url, username, password));
    } catch (SQLException e) {
      int errorCode = e.getErrorCode();
      if (errorCode == 1044 || errorCode == 1045) {
        String host = PreferenceManager.getInstance().get(PreferenceManager.DB_HOST);

        Frame parent = Globals.isHeadless() ? null : IGV.getMainFrame();
        LoginDialog dlg = new LoginDialog(parent, false, host, false);
        dlg.setVisible(true);
        if (dlg.isCanceled()) {
          throw new RuntimeException("Must login to access" + host);
        }
        username = dlg.getUsername();
        password = new String(dlg.getPassword());
        return connect(url);

      } else {
        MessageUtils.showMessage("<html>Error connecting to database: <br>" + e.getMessage());
        return null;
      }
    }
  }
Exemple #10
0
  private void processResource(Session session, Element element, HashMap additionalInformation) {

    String nodeName = element.getNodeName();
    boolean oldSession = nodeName.equals(SessionElement.DATA_FILE.getText());

    String label = getAttribute(element, SessionAttribute.LABEL.getText());
    String name = getAttribute(element, SessionAttribute.NAME.getText());
    String sampleId = getAttribute(element, SessionAttribute.SAMPLE_ID.getText());
    String description = getAttribute(element, SessionAttribute.DESCRIPTION.getText());
    String type = getAttribute(element, SessionAttribute.TYPE.getText());
    String coverage = getAttribute(element, SessionAttribute.COVERAGE.getText());
    String trackLine = getAttribute(element, SessionAttribute.TRACK_LINE.getText());
    String colorString = getAttribute(element, SessionAttribute.COLOR.getText());

    String relPathValue = getAttribute(element, SessionAttribute.RELATIVE_PATH.getText());
    boolean isRelativePath = ((relPathValue != null) && relPathValue.equalsIgnoreCase("true"));
    String serverURL = getAttribute(element, SessionAttribute.SERVER_URL.getText());

    // Older sessions used the "name" attribute for the path.
    String path = getAttribute(element, SessionAttribute.PATH.getText());

    if (oldSession && name != null) {
      path = name;
      int idx = name.lastIndexOf("/");
      if (idx > 0 && idx + 1 < name.length()) {
        name = name.substring(idx + 1);
      }
    }

    ResourceLocator resourceLocator;
    if (isRelativePath) {
      final String sessionPath = session.getPath();

      String absolutePath;
      if (sessionPath == null) {
        log.error("Null session path -- this is not expected");
        MessageUtils.showMessage("Unexpected error loading session: null session path");
        return;
      }
      absolutePath = FileUtils.getAbsolutePath(path, sessionPath);
      fullToRelPathMap.put(absolutePath, path);
      resourceLocator = new ResourceLocator(serverURL, absolutePath);

      // If the resourceLocator is relative, we assume coverage is as well
      if (coverage != null) {
        String absoluteCoveragePath = FileUtils.getAbsolutePath(coverage, sessionPath);
        resourceLocator.setCoverage(absoluteCoveragePath);
      }
    } else {
      resourceLocator = new ResourceLocator(serverURL, path);
      resourceLocator.setCoverage(coverage);
    }

    String url = getAttribute(element, SessionAttribute.URL.getText());
    if (url == null) {
      url = getAttribute(element, SessionAttribute.FEATURE_URL.getText());
    }
    resourceLocator.setUrl(url);

    String infolink = getAttribute(element, SessionAttribute.HYPERLINK.getText());
    if (infolink == null) {
      infolink = getAttribute(element, SessionAttribute.INFOLINK.getText());
    }
    resourceLocator.setInfolink(infolink);

    // Label is deprecated in favor of name.
    if (name != null) {
      resourceLocator.setName(name);
    } else {
      resourceLocator.setName(label);
    }

    resourceLocator.setSampleId(sampleId);

    resourceLocator.setDescription(description);
    // This test added to get around earlier bug in the writer
    if (type != null && !type.equals("local")) {
      resourceLocator.setType(type);
    }
    resourceLocator.setCoverage(coverage);
    resourceLocator.setTrackLine(trackLine);

    if (colorString != null) {
      try {
        Color c = ColorUtilities.stringToColor(colorString);
        resourceLocator.setColor(c);
      } catch (Exception e) {
        log.error("Error setting color: ", e);
      }
    }

    dataFiles.add(resourceLocator);

    NodeList elements = element.getChildNodes();
    process(session, elements, additionalInformation);
  }
Exemple #11
0
  private void processResources(Session session, Element element, HashMap additionalInformation) {
    dataFiles = new ArrayList();
    missingDataFiles = new ArrayList();
    NodeList elements = element.getChildNodes();
    process(session, elements, additionalInformation);

    if (missingDataFiles.size() > 0) {
      StringBuffer message = new StringBuffer();
      message.append("<html>The following data file(s) could not be located.<ul>");
      for (ResourceLocator file : missingDataFiles) {
        if (file.isLocal()) {
          message.append("<li>");
          message.append(file.getPath());
          message.append("</li>");
        } else {
          message.append("<li>Server: ");
          message.append(file.getServerURL());
          message.append("  Path: ");
          message.append(file.getPath());
          message.append("</li>");
        }
      }
      message.append("</ul>");
      message.append("Common reasons for this include: ");
      message.append("<ul><li>The session or data files have been moved.</li> ");
      message.append(
          "<li>The data files are located on a drive that is not currently accessible.</li></ul>");
      message.append("</html>");

      MessageUtils.showMessage(message.toString());
    }
    if (dataFiles.size() > 0) {

      final List<String> errors = new ArrayList<String>();

      // Load files concurrently -- TODO, put a limit on # of threads?
      List<Thread> threads = new ArrayList(dataFiles.size());
      long t0 = System.currentTimeMillis();
      int i = 0;
      List<Runnable> synchronousLoads = new ArrayList<Runnable>();
      for (final ResourceLocator locator : dataFiles) {

        final String suppliedPath = locator.getPath();
        final String relPath = fullToRelPathMap.get(suppliedPath);

        Runnable runnable =
            new Runnable() {
              public void run() {
                List<Track> tracks = null;
                try {
                  tracks = igv.load(locator);
                  for (Track track : tracks) {
                    if (track == null) {
                      log.info("Null track for resource " + locator.getPath());
                      continue;
                    }

                    String id = track.getId();
                    if (id == null) {
                      log.info("Null track id for resource " + locator.getPath());
                      continue;
                    }

                    if (relPath != null) {
                      id = id.replace(suppliedPath, relPath);
                    }

                    List<Track> trackList = trackDictionary.get(id);
                    if (trackList == null) {
                      trackList = new ArrayList();
                      trackDictionary.put(id, trackList);
                    }
                    trackList.add(track);
                  }
                } catch (Exception e) {
                  log.error("Error loading resource " + locator.getPath(), e);
                  String ms =
                      "<b>" + locator.getPath() + "</b><br>&nbs;p&nbsp;" + e.toString() + "<br>";
                  errors.add(ms);
                }
              }
            };

        boolean isAlignment =
            locator.getPath().endsWith(".bam")
                || locator.getPath().endsWith(".entries")
                || locator.getPath().endsWith(".sam");

        // Run synchronously if in batch mode or if there are no "track" elments, or if this is an
        // alignment file
        if (isAlignment || Globals.isBatch() || !hasTrackElments) {
          synchronousLoads.add(runnable);
        } else {
          Thread t = new Thread(runnable);
          threads.add(t);
          t.start();
        }
        i++;
      }
      // Wait for all threads to complete
      for (Thread t : threads) {
        try {
          t.join();
        } catch (InterruptedException ignore) {
        }
      }

      // Now load data that must be loaded synchronously
      for (Runnable runnable : synchronousLoads) {
        runnable.run();
      }

      long dt = System.currentTimeMillis() - t0;
      log.debug("Total load time = " + dt);

      if (errors.size() > 0) {
        StringBuffer buf = new StringBuffer();
        buf.append("<html>Errors were encountered loading the session:<br>");
        for (String msg : errors) {
          buf.append(msg);
        }
        MessageUtils.showMessage(buf.toString());
      }
    }
    dataFiles = null;
  }
Exemple #12
0
  private void processRootNode(Session session, Node node, HashMap additionalInformation) {

    if ((node == null) || (session == null)) {
      MessageUtils.showMessage("Invalid session file: root node not found");
      return;
    }

    String nodeName = node.getNodeName();
    if (!(nodeName.equalsIgnoreCase(SessionElement.GLOBAL.getText())
        || nodeName.equalsIgnoreCase(SessionElement.SESSION.getText()))) {
      MessageUtils.showMessage(
          "Session files must begin with a \"Global\" or \"Session\" element.  Found: " + nodeName);
    }
    process(session, node, additionalInformation);

    Element element = (Element) node;

    // Load the genome, which can be an ID, or a path or URL to a .genome or indexed fasta file.
    String genomeId = getAttribute(element, SessionAttribute.GENOME.getText());
    if (genomeId != null && genomeId.length() > 0) {
      if (genomeId.equals(GenomeManager.getInstance().getGenomeId())) {
        // We don't have to reload the genome, but the gene track for the current genome should be
        // restored.
        Genome genome = GenomeManager.getInstance().getCurrentGenome();
        IGV.getInstance().setGenomeTracks(genome.getGeneTrack());
      } else {
        // Selecting a genome will actually "reset" the session so we have to
        // save the path and restore it.
        String sessionPath = session.getPath();
        if (IGV.getInstance().getGenomeIds().contains(genomeId)) {
          IGV.getInstance().selectGenomeFromList(genomeId);
        } else {
          String genomePath = genomeId;
          if (!ParsingUtils.pathExists(genomePath)) {
            genomePath = FileUtils.getAbsolutePath(genomeId, session.getPath());
          }
          if (ParsingUtils.pathExists(genomePath)) {
            try {
              IGV.getInstance().loadGenome(genomePath, null);
            } catch (IOException e) {
              throw new RuntimeException("Error loading genome: " + genomeId);
            }
          } else {
            MessageUtils.showMessage("Warning: Could not locate genome: " + genomeId);
          }
        }
        session.setPath(sessionPath);
      }
    }

    session.setLocus(getAttribute(element, SessionAttribute.LOCUS.getText()));
    session.setGroupTracksBy(getAttribute(element, SessionAttribute.GROUP_TRACKS_BY.getText()));

    String removeEmptyTracks = getAttribute(element, "removeEmptyTracks");
    if (removeEmptyTracks != null) {
      try {
        Boolean b = Boolean.parseBoolean(removeEmptyTracks);
        session.setRemoveEmptyPanels(b);
      } catch (Exception e) {
        log.error("Error parsing removeEmptyTracks string: " + removeEmptyTracks, e);
      }
    }

    String versionString = getAttribute(element, SessionAttribute.VERSION.getText());
    try {
      version = Integer.parseInt(versionString);
    } catch (NumberFormatException e) {
      log.error("Non integer version number in session file: " + versionString);
    }
    session.setVersion(version);

    NodeList elements = element.getChildNodes();
    process(session, elements, additionalInformation);

    // ReferenceFrame.getInstance().invalidateLocationScale();
  }
Exemple #13
0
  private void loadAlignmentsTrack(ResourceLocator locator, List<Track> newTracks, Genome genome)
      throws IOException {

    try {
      String dsName = locator.getTrackName();

      // If the user tried to load the index,  look for the file (this is a common mistake)
      if (locator.getTypeString().endsWith(".sai") || locator.getTypeString().endsWith(".bai")) {
        MessageUtils.showMessage(
            "<html><b>ERROR:</b> Loading SAM/BAM index files are not supported:  "
                + locator.getPath()
                + "<br>Load the SAM or BAM file directly. ");
        return;
      }

      AlignmentDataManager dataManager = new AlignmentDataManager(locator, genome);

      // Check that alignments we loaded actually match some data.  Many BAM files will contain some
      // sequences
      // not represented in the genome, buf if there are no matches warn the user.
      List<String> seqNames = dataManager.getSequenceNames();
      if (seqNames != null && seqNames.size() > 0) {
        if (!checkSequenceNames(locator.getPath(), genome, seqNames)) {
          return;
        }
      }

      if (locator.getTypeString().endsWith("bam") || locator.getTypeString().endsWith("cram")) {
        if (!dataManager.hasIndex()) {
          MessageUtils.showMessage(
              "<html>Could not load index file for: "
                  + locator.getPath()
                  + "<br>  An index file is required for SAM & BAM files.");
          return;
        }
      }

      AlignmentTrack alignmentTrack =
          new AlignmentTrack(locator, dataManager, genome); // parser.loadTrack(locator, dsName);
      alignmentTrack.setName(dsName);
      alignmentTrack.setVisible(
          PreferenceManager.getInstance().getAsBoolean(PreferenceManager.SAM_SHOW_ALIGNMENT_TRACK));

      // Create coverage track
      CoverageTrack covTrack =
          new CoverageTrack(locator, dsName + " Coverage", alignmentTrack, genome);
      covTrack.setVisible(
          PreferenceManager.getInstance().getAsBoolean(PreferenceManager.SAM_SHOW_COV_TRACK));
      newTracks.add(covTrack);
      covTrack.setDataManager(dataManager);
      dataManager.setCoverageTrack(covTrack);

      alignmentTrack.setCoverageTrack(covTrack);

      // Search for precalculated coverage data
      // Skip for GA4GH & SU2C resources
      if (!(Ga4ghAPIHelper.RESOURCE_TYPE.equals(locator.getType())
          || locator.getPath().contains("dataformat=.bam")
          || OAuthUtils.isGoogleCloud(locator.getPath()))) {

        String covPath = locator.getCoverage();
        if (covPath == null) {
          boolean bypassFileAutoDiscovery =
              PreferenceManager.getInstance()
                  .getAsBoolean(PreferenceManager.BYPASS_FILE_AUTO_DISCOVERY);
          String path = locator.getPath();
          if (!bypassFileAutoDiscovery && !path.contains("/query.cgi?")) {
            covPath = path + ".tdf";
          }
        }
        if (covPath != null) {
          if (FileUtils.resourceExists(covPath)) {
            log.debug("Loading TDF for coverage: " + covPath);
            try {
              TDFReader reader = TDFReader.getReader(covPath);
              TDFDataSource ds = new TDFDataSource(reader, 0, dsName + " coverage", genome);
              covTrack.setDataSource(ds);
            } catch (Exception e) {
              log.error("Error loading coverage TDF file", e);
            }
          }
        }
      }

      boolean showSpliceJunctionTrack =
          PreferenceManager.getInstance().getAsBoolean(PreferenceManager.SAM_SHOW_JUNCTION_TRACK);

      SpliceJunctionTrack spliceJunctionTrack =
          new SpliceJunctionTrack(
              locator,
              dsName + " Junctions",
              dataManager,
              alignmentTrack,
              SpliceJunctionTrack.StrandOption.BOTH);
      spliceJunctionTrack.setHeight(60);
      spliceJunctionTrack.setVisible(showSpliceJunctionTrack);
      newTracks.add(spliceJunctionTrack);

      alignmentTrack.setSpliceJunctionTrack(spliceJunctionTrack);

      newTracks.add(alignmentTrack);

      log.debug("Alignment track loaded");

    } catch (IndexNotFoundException e) {
      MessageUtils.showMessage(
          "<html>Could not find the index file for  <br><br>&nbsp;&nbsp;"
              + e.getSamFile()
              + "<br><br>Note: The index file can be created using igvtools and must be in the same directory as the .sam file.");
    }
  }
Exemple #14
0
  /**
   * Switches on various attributes of locator (mainly locator path extension and whether the
   * locator is indexed) to call the appropriate loading method.
   *
   * @param locator
   * @param genome
   * @return
   */
  public List<Track> load(ResourceLocator locator, Genome genome) throws DataLoadException {

    final String path = locator.getPath().trim();
    log.info("Loading resource, path " + path);
    try {
      String typeString = locator.getTypeString();

      if (typeString.endsWith(".tbi")) {
        MessageUtils.showMessage(
            "<html><b>Error:</b>File type '.tbi' is not recognized.  If this is a 'tabix' index <br>"
                + " load the associated gzipped file, which should have an extension of '.gz'");
      }

      // This list will hold all new tracks created for this locator
      List<Track> newTracks = new ArrayList<Track>();

      String dbUrl = locator.getDBUrl();
      LoadHandler handler = getTrackLoaderHandler(typeString);
      if (dbUrl != null) {
        this.loadFromDatabase(locator, newTracks, genome);
      } else if (typeString.endsWith(".dbxml")) {
        loadFromDBProfile(locator, newTracks);
      } else if (typeString.endsWith(".gmt")) {
        loadGMT(locator);
      } else if (typeString.equals("das")) {
        loadDASResource(locator, newTracks);
      } else if (typeString.endsWith(".vcf.list")) {
        loadVCFListFile(locator, newTracks, genome);
      } else if (typeString.endsWith(".trio")) {
        loadTrioData(locator);
      } else if (typeString.endsWith("varlist")) {
        VariantListManager.loadVariants(locator);
      } else if (typeString.endsWith("samplepathmap")) {
        VariantListManager.loadSamplePathMap(locator);
      } else if (typeString.endsWith(".rnai.gct")) {
        loadRnaiGctFile(locator, newTracks, genome);
      } else if (typeString.endsWith(".gct")
          || typeString.endsWith("res")
          || typeString.endsWith("tab")) {
        loadGctFile(locator, newTracks, genome);
      } else if (typeString.endsWith(".gbk") || typeString.endsWith(".gb")) {
        loadGbkFile(locator, newTracks, genome);
      } else if (typeString.endsWith(".cn")
          || typeString.endsWith(".xcn")
          || typeString.endsWith(".snp")
          || typeString.endsWith(".igv")
          || typeString.endsWith(".loh")) {
        loadIGVFile(locator, newTracks, genome);
      } else if (typeString.endsWith(".cbs")
          || typeString.endsWith(".seg")
          || typeString.endsWith("glad")
          || typeString.endsWith("birdseye_canary_calls")
          || typeString.endsWith(".seg.zip")) {
        loadSegFile(locator, newTracks, genome);
      } else if (typeString.endsWith(".gistic")) {
        loadGisticFile(locator, newTracks);
      } else if (typeString.endsWith(".gs")) {
        loadRNAiGeneScoreFile(locator, newTracks, RNAIGeneScoreParser.Type.GENE_SCORE, genome);
      } else if (typeString.endsWith(".riger")) {
        loadRNAiGeneScoreFile(locator, newTracks, RNAIGeneScoreParser.Type.POOLED, genome);
      } else if (typeString.endsWith(".hp")) {
        loadRNAiHPScoreFile(locator);
      } else if (typeString.contains(".tabblastn") || typeString.endsWith(".orthologs")) {
        loadSyntentyMapping(locator, newTracks);
      } else if (typeString.endsWith(".sam")
          || typeString.endsWith(".bam")
          || typeString.endsWith(".cram")
          || typeString.endsWith(".sam.list")
          || typeString.endsWith(".bam.list")
          || typeString.endsWith(".aligned")
          || typeString.endsWith(".sai")
          || typeString.endsWith(".bai")
          || typeString.equals("alist")
          || typeString.equals(Ga4ghAPIHelper.RESOURCE_TYPE)) {
        loadAlignmentsTrack(locator, newTracks, genome);
      } else if (typeString.endsWith(".wig")
          || typeString.endsWith(".bedgraph")
          || typeString.endsWith(".bdg")
          || typeString.endsWith("cpg.txt")
          || typeString.endsWith(".expr")) {
        loadWigFile(locator, newTracks, genome);
      } else if (typeString.endsWith("fpkm_tracking")
          || typeString.endsWith("gene_exp.diff")
          || typeString.endsWith("cds_exp.diff")) {
        loadCufflinksFile(locator, newTracks, genome);
      } else if (typeString.contains(".dranger")) {
        loadDRangerFile(locator, newTracks, genome);
      } else if (typeString.endsWith(".ewig.tdf") || (typeString.endsWith(".ewig.ibf"))) {
        loadEwigIBFFile(locator, newTracks, genome);
      } else if (typeString.endsWith(".bw")
          || typeString.endsWith(".bb")
          || typeString.endsWith(".bigwig")
          || typeString.endsWith(".bigbed")) {
        loadBWFile(locator, newTracks, genome);
      } else if (typeString.endsWith(".ibf") || typeString.endsWith(".tdf")) {
        loadTDFFile(locator, newTracks, genome);
      } else if (typeString.endsWith(".counts")) {
        loadGobyCountsArchive(locator, newTracks, genome);
      } else if (WiggleParser.isWiggle(locator)) {
        loadWigFile(locator, newTracks, genome);
      } else if (typeString.endsWith(".maf")) {
        loadMultipleAlignmentTrack(locator, newTracks, genome);
      } else if (typeString.endsWith(".maf.dict")) {
        loadMultipleAlignmentTrack(locator, newTracks, genome);
      } else if (typeString.contains(".peak.bin")) {
        loadPeakTrack(locator, newTracks, genome);
      } else if (typeString.endsWith("mage-tab")
          || ExpressionFileParser.parsableMAGE_TAB(locator)) {
        locator.setDescription("MAGE_TAB");
        loadGctFile(locator, newTracks, genome);
      } else if (typeString.endsWith(".bp")) {
        loadBasePairFile(locator, newTracks, genome);
      } else if (GWASParser.isGWASFile(typeString)) {
        loadGWASFile(locator, newTracks, genome);
      } else if (GobyAlignmentQueryReader.supportsFileType(path)) {
        loadAlignmentsTrack(locator, newTracks, genome);
      } else if (typeString.endsWith(".list")) {
        // This should be deprecated
        loadListFile(locator, newTracks, genome);
      } else if (typeString.endsWith(".smap")) {
        loadSMAPFile(locator, newTracks, genome);
      } else if (CodecFactory.hasCodec(locator, genome) && !forceNotTribble(typeString)) {
        loadTribbleFile(locator, newTracks, genome);
      } else if (handler != null) {
        // Custom loader specified
        log.info(String.format("Loading %s with %s", path, handler));
        handler.load(path, newTracks);
      } else if (AttributeManager.isSampleInfoFile(locator)) {
        // This might be a sample information file.
        AttributeManager.getInstance().loadSampleInfo(locator);
      } else {
        MessageUtils.showMessage("<html>Unknown file type: " + path + "<br>Check file extension");
      }

      // Track line
      TrackProperties tp = null;
      String trackLine = locator.getTrackLine();
      if (trackLine != null) {
        tp = new TrackProperties();
        ParsingUtils.parseTrackLine(trackLine, tp);
      }

      for (Track track : newTracks) {

        if (locator.getFeatureInfoURL() != null) {
          track.setUrl(locator.getFeatureInfoURL());
        }
        if (tp != null) {
          track.setProperties(tp);
        }
        if (locator.getColor() != null) {
          track.setColor(locator.getColor());
        }
        if (locator.getSampleId() != null) {
          track.setSampleId(locator.getSampleId());
        }
      }

      return newTracks;
    } catch (Exception e) {
      if (!NOLogExceptions.contains(e.getClass())) {
        log.error(e.getMessage(), e);
      }
      throw new DataLoadException(e.getMessage());
    }
  }
Exemple #15
0
  /**
   * Create an index for an alignment or feature file The output index will have the same base name
   * is the input file, although it may be in a different directory. An appropriate index extension
   * (.sai, .idx, etc.) will be appended.
   *
   * @param ifile
   * @param typeString
   * @param outputDir
   * @param indexType
   * @param binSize
   * @throws IOException
   */
  public String doIndex(
      String ifile, String typeString, String outputDir, int indexType, int binSize)
      throws IOException {
    File inputFile = new File(ifile);

    if (outputDir == null) {
      outputDir = inputFile.getParent();
    }
    String outputFileName = (new File(outputDir, inputFile.getName())).getAbsolutePath();

    if (typeString.endsWith("gz")) {
      System.out.println("Cannot index a gzipped file");
      throw new PreprocessingException("Cannot index a gzipped file");
    }

    if (typeString.endsWith("bam")) {
      String msg =
          "Cannot index a BAM file. Use the samtools package for sorting and indexing BAM files.";
      System.out.println(msg);
      throw new PreprocessingException(msg);
    }

    // We have different naming conventions for different index files
    if (typeString.endsWith("sam") && !outputFileName.endsWith(".sai")) {
      outputFileName += ".sai";
    } else if (typeString.endsWith("bam") && !outputFileName.endsWith(".bai")) {
      outputFileName += ".bai";
    } else if (typeString.endsWith("fa") && !outputFileName.endsWith(".fai")) {
      outputFileName += ".fai";
    } else if (typeString.endsWith("fasta") && !outputFileName.endsWith(".fai")) {
      outputFileName += ".fai";
    } else if (!typeString.endsWith("sam")
        && !typeString.endsWith("bam")
        && !outputFileName.endsWith(".idx")) {
      outputFileName += ".idx";
    }

    File outputFile = new File(outputFileName);

    // Sam/FASTA files are special
    try {
      if (typeString.endsWith("sam")) {
        AlignmentIndexer indexer = AlignmentIndexer.getInstance(inputFile, null, null);
        indexer.createSamIndex(outputFile);
        return outputFileName;
      } else if (typeString.equals(".fa") || typeString.equals(".fasta")) {
        FastaUtils.createIndexFile(inputFile.getAbsolutePath(), outputFileName);
        return outputFileName;
      }
    } catch (Exception e) {
      e.printStackTrace();
      // Delete output file as it is probably corrupt
      if (outputFile.exists()) {
        outputFile.delete();
      }
    }

    Genome genome = null; // <= don't do chromosome conversion
    FeatureCodec codec = CodecFactory.getCodec(ifile, genome);
    if (codec != null) {
      try {
        createTribbleIndex(ifile, outputFile, indexType, binSize, codec);
      } catch (TribbleException.MalformedFeatureFile e) {
        StringBuffer buf = new StringBuffer();
        buf.append("<html>Files must be sorted by start position prior to indexing.<br>");
        buf.append(e.getMessage());
        buf.append(
            "<br><br>Note: igvtools can be used to sort the file, select \"File > Run igvtools...\".");
        MessageUtils.showMessage(buf.toString());
      }
    } else {
      throw new DataLoadException("Unknown File Type", ifile);
    }
    System.out.flush();
    return outputFileName;
  }
Exemple #16
0
  private void parseColumnLine(String tmp) {
    String[] tokens = tmp.split("\\s+");
    String neg_colnum = "Error parsing column line: " + tmp + "<br>Column numbers must be > 0";
    if (tokens.length > 1) {
      for (int i = 1; i < tokens.length; i++) {
        String[] kv = tokens[i].split("=");
        if (kv.length == 2) {
          if (kv[0].toLowerCase().equals("chr")) {
            int c = Integer.parseInt(kv[1]);
            if (c < 1) {
              MessageUtils.showMessage(neg_colnum);
            } else {
              chrColumn = c - 1;
            }
          } else if (kv[0].toLowerCase().equals("start")) {
            int c = Integer.parseInt(kv[1]);
            if (c < 1) {
              MessageUtils.showMessage(neg_colnum);
            } else {
              startColumn = c - 1;
            }

          } else if (kv[0].toLowerCase().equals("end")) {
            int c = Integer.parseInt(kv[1]);
            if (c < 1) {
              MessageUtils.showMessage(neg_colnum);
            } else {
              endColumn = c - 1;
              hasEndLocations = true;
            }

          } else if (kv[0].toLowerCase().equals("probe")) {
            int c = Integer.parseInt(kv[1]);
            if (c < 1) {
              MessageUtils.showMessage(neg_colnum);
            } else {
              probeColumn = c - 1;
            }

          } else if (kv[0].toLowerCase().equals("data")) {
            // examples  4,  4-8,  4-
            String[] se = kv[1].split("-");
            int c = Integer.parseInt(se[0]);
            if (c < 1) {
              MessageUtils.showMessage(neg_colnum);
            } else {
              this.firstDataColumn = c - 1;
            }
            if (se.length > 1) {

              c = Integer.parseInt(se[1]);
              if (c < 1) {
                MessageUtils.showMessage(neg_colnum);
              } else {
                this.lastDataColumn = c - 1;
              }
            }
          }
        }
      }
    }
  }