Beispiel #1
0
  public AlgorithmData getScriptParameters(IFramework framework) {

    this.experiment = framework.getData().getExperiment();
    exptNamesVector = new Vector<String>();
    int number_of_samples = experiment.getNumberOfSamples();
    // int number_of_genes = experiment.getNumberOfGenes();

    for (int i = 0; i < number_of_samples; i++) {
      exptNamesVector.add(framework.getData().getFullSampleName(experiment.getSampleIndex(i)));
    }

    DEGseqInitBox DEGseqDialog =
        new DEGseqInitBox(
            (JFrame) framework.getFrame(), true, exptNamesVector, framework.getClusterRepository(1)
            // framework.getClusterRepository(0)
            );
    DEGseqDialog.setVisible(true);

    if (!DEGseqDialog.isOkPressed()) return null;

    if (DEGseqDialog.getTestDesign() == DEGseqInitBox.TWO_CLASS) {
      if (DEGseqDialog.getSelectionDesign() == DEGseqInitBox.CLUSTER_SELECTION) {
        groupAssignments = DEGseqDialog.getClusterTwoClassAssignments();
      }
      if (DEGseqDialog.getSelectionDesign() == DEGseqInitBox.BUTTON_SELECTION) {
        groupAssignments = DEGseqDialog.getTwoClassAssignments();
      }
    }

    AlgorithmData data = new AlgorithmData();

    // alg name
    data.addParam("name", "DESeq");

    // alg type
    data.addParam("alg-type", "data-visualization");

    // output class
    data.addParam("output-class", "partition-output");

    // output nodes
    String[] outputNodes = new String[2];
    outputNodes[0] = "Significant Genes";
    outputNodes[1] = "Non-significant Genes";

    data.addStringArray("output-nodes", outputNodes);

    return data;
  }
Beispiel #2
0
 private void setClusters(int[][] sampleArray) {
   if (sampleArray == null || sampleArray.length == 0) sampleArray = new int[1][];
   clusterCount = sampleArray.length;
   clusterNames = new String[clusterCount];
   clusterColors = new Color[clusterCount];
   clusters = new int[clusterCount][];
   for (int i = 0; i < clusterCount; i++) {
     if (sampleArray[i] == null) {
       int numSamps = experiment.getNumberOfSamples();
       clusters[i] = new int[numSamps];
       for (int j = 0; j < numSamps; j++) {
         clusters[i][j] = j;
       }
       clusterColors[i] = Color.white;
       clusterNames[i] = "All Samples";
     } else {
       clusters[i] = sampleArray[i];
       clusterColors[i] = createClusterColor(i);
       if (sampleClusterNames == null || sampleClusterNames[i].length() < 1) {
         clusterNames[i] = "(Group " + (i + 1) + ")";
       } else {
         clusterNames[i] = sampleClusterNames[i];
       }
     }
   }
 }
Beispiel #3
0
  public DefaultMutableTreeNode executeScript(
      IFramework framework, AlgorithmData algData, Experiment experiment)
      throws AlgorithmException {

    Listener listener = new Listener();
    this.experiment = experiment;
    this.data = framework.getData();
    // this.timeAssignments = algData.getIntArray("time_assignments");
    this.groupAssignments = algData.getIntArray("condition_assignments");

    exptNamesVector = new Vector<String>();
    int number_of_samples = experiment.getNumberOfSamples();

    for (int i = 0; i < number_of_samples; i++) {
      exptNamesVector.add(this.data.getFullSampleName(i));
    }

    try {
      algData.addMatrix("experiment", experiment.getMatrix());
      algorithm = framework.getAlgorithmFactory().getAlgorithm("MINET");
      algorithm.addAlgorithmListener(listener);

      this.progress = new Progress(framework.getFrame(), "Running MINET Analysis...", listener);
      this.progress.show();

      long start = System.currentTimeMillis();
      AlgorithmData result = algorithm.execute(algData);
      long time = System.currentTimeMillis() - start;

      AlgorithmParameters params = algData.getParams();

      GeneralInfo info = new GeneralInfo();
      return createResultTree(info);

    } finally {
      if (algorithm != null) {
        algorithm.removeAlgorithmListener(listener);
      }
      if (progress != null) {
        progress.dispose();
      }
    }
  }
Beispiel #4
0
 public void setClusters(Cluster[] clusterArray) {
   if (clusterArray == null || clusterArray.length == 0) clusterArray = new Cluster[1];
   clusterCount = clusterArray.length;
   clusterNames = new String[clusterCount];
   clusterColors = new Color[clusterCount];
   clusters = new int[clusterCount][];
   for (int i = 0; i < clusterCount; i++) {
     if (clusterArray[i] == null) {
       int numSamps = experiment.getNumberOfSamples();
       clusters[i] = new int[numSamps];
       for (int j = 0; j < numSamps; j++) {
         clusters[i][j] = j;
       }
       clusterColors[i] = Color.white;
       clusterNames[i] = "All Samples";
     } else {
       clusters[i] = clusterArray[i].getIndices();
       clusterColors[i] = clusterArray[i].getClusterColor();
       clusterNames[i] = clusterArray[i].getClusterLabel();
       if (clusterNames[i].length() < 1) clusterNames[i] = "(Cluster " + (i + 1) + ")";
     }
   }
 }
  private void saveCluster(File file, Experiment experiment, IData data, int[] rows)
      throws Exception {
    PrintWriter out = new PrintWriter(new FileOutputStream(file));
    String[] fieldNames = data.getFieldNames();
    out.print("Original row");
    out.print("\t");
    for (int i = 0; i < fieldNames.length; i++) {
      out.print(fieldNames[i]);
      // if (i < fieldNames.length - 1) {
      out.print("\t");
      // }
    }
    for (int i = 0; i < geneGroupMeans[0].length; i++) {
      out.print("Group" + (i + 1) + " mean\t");
      out.print("Group" + (i + 1) + " std.dev.\t");
    }
    // out.print("\t");
    out.print("F ratio");
    out.print("\t");
    out.print("SS(Groups)\t");
    out.print("SS(Error)\t");
    out.print("df (Groups)\t");
    out.print("df (Error)\t");
    out.print("raw p value\t");
    out.print("adj p value");

    // out.print("UniqueID\tName");
    for (int i = 0; i < experiment.getNumberOfSamples(); i++) {
      out.print("\t");
      out.print(data.getFullSampleName(experiment.getSampleIndex(i)));
    }
    out.print("\n");
    for (int i = 0; i < rows.length; i++) {
      out.print(Integer.toString(experiment.getGeneIndexMappedToData(rows[i]) + 1));
      // out.print(data.getUniqueId(rows[i]));
      out.print("\t");
      // out.print(data.getGeneName(rows[i]));
      for (int k = 0; k < fieldNames.length; k++) {
        out.print(data.getElementAttribute(experiment.getGeneIndexMappedToData(rows[i]), k));
        // if (k < fieldNames.length - 1) {
        out.print("\t");
        // }
      }
      for (int j = 0; j < geneGroupMeans[rows[i]].length; j++) {
        out.print(geneGroupMeans[rows[i]][j] + "\t");
        out.print(geneGroupSDs[rows[i]][j] + "\t");
      }
      // out.print("\t");
      out.print("" + ((Float) fValues.get(rows[i])).floatValue());
      out.print("\t");
      out.print("" + ((Float) ssGroups.get(rows[i])).floatValue());
      out.print("\t");
      out.print("" + ((Float) ssError.get(rows[i])).floatValue());
      out.print("\t");
      out.print("" + ((Float) dfNumValues.get(rows[i])).floatValue());
      out.print("\t");
      out.print("" + ((Float) dfDenomValues.get(rows[i])).floatValue());
      out.print("\t");
      out.print("" + ((Float) rawPValues.get(rows[i])).floatValue());
      out.print("\t");
      out.print("" + ((Float) adjPValues.get(rows[i])).floatValue());
      for (int j = 0; j < experiment.getNumberOfSamples(); j++) {
        out.print("\t");
        out.print(Float.toString(experiment.get(rows[i], j)));
      }
      out.print("\n");
    }
    out.flush();
    out.close();
  }
Beispiel #6
0
  /**
   * Gathers data for a set of genes
   *
   * @param geneIndices
   */
  private void getChartData(int[] geneIndices, int multigeneIndex) {
    try {
      lowerOutliers[multigeneIndex] = new float[clusterCount][];
      upperOutliers[multigeneIndex] = new float[clusterCount][];
      expressionSDs[multigeneIndex] = new float[clusterCount];
      expressionAverages[multigeneIndex] = new float[clusterCount];
      expressionMedian[multigeneIndex] = new float[clusterCount];
      expressionQ1[multigeneIndex] = new float[clusterCount];
      expressionQ3[multigeneIndex] = new float[clusterCount];
      expressionIQR[multigeneIndex] = new float[clusterCount];
      expressionLowerWhisker[multigeneIndex] = new float[clusterCount];
      expressionUpperWhisker[multigeneIndex] = new float[clusterCount];
      for (int i = 0; i < clusterCount; i++) {
        float average = 0;
        float sum = 0;
        int membership = 0;
        for (int j = 0; j < clusters[i].length; j++) {
          for (int k = 0; k < geneIndices.length; k++) {
            average = average + experiment.get(geneIndices[k], clusters[i][j]);
            membership++;
          }
        }
        average = average / (float) membership;
        expressionAverages[multigeneIndex][i] = average;
        for (int j = 0; j < clusters[i].length; j++) {
          for (int k = 0; k < geneIndices.length; k++) {
            sum =
                sum + (float) Math.pow(experiment.get(geneIndices[k], clusters[i][j]) - average, 2);
          }
        }
        sum = sum / (float) membership;
        expressionSDs[multigeneIndex][i] = (float) Math.sqrt(sum);

        // get box plot stuff
        float[] expression = new float[clusters[i].length * geneIndices.length];
        int expindex = 0;
        for (int j = 0; j < clusters[i].length; j++) {
          for (int k = 0; k < geneIndices.length; k++) {
            expression[expindex++] = (experiment.get(geneIndices[k], clusters[i][j]));
          }
        }
        Arrays.sort(expression);
        expressionMedian[multigeneIndex][i] = getMedian(expression);

        float[] lower = new float[expression.length / 2];
        float[] upper = new float[expression.length / 2];
        for (int j = 0; j < lower.length; j++) {
          lower[j] = expression[j];
          upper[upper.length - 1 - j] = expression[expression.length - 1 - j];
        }
        expressionQ1[multigeneIndex][i] = getMedian(lower);
        expressionQ3[multigeneIndex][i] = getMedian(upper);
        expressionIQR[multigeneIndex][i] =
            expressionQ3[multigeneIndex][i] - expressionQ1[multigeneIndex][i];
        expressionLowerWhisker[multigeneIndex][i] =
            expressionQ1[multigeneIndex][i] - 1.5f * expressionIQR[multigeneIndex][i];
        expressionUpperWhisker[multigeneIndex][i] =
            expressionQ3[multigeneIndex][i] + 1.5f * expressionIQR[multigeneIndex][i];

        int upperCount = 0;
        int lowerCount = 0;
        for (int index = 0; index < expression.length; index++) {
          if (expression[index] < expressionLowerWhisker[multigeneIndex][i]) lowerCount++;
          if (expression[index] > expressionUpperWhisker[multigeneIndex][i]) upperCount++;
        }
        lowerOutliers[multigeneIndex][i] = new float[lowerCount];
        upperOutliers[multigeneIndex][i] = new float[upperCount];
        for (int j = 0; j < lowerOutliers[multigeneIndex][i].length; j++) {
          lowerOutliers[multigeneIndex][i][j] = expression[j];
        }
        for (int j = 0; j < upperOutliers[multigeneIndex][i].length; j++) {
          upperOutliers[multigeneIndex][i][j] = expression[expression.length - 1 - j];
        }
      }
    } catch (Exception e) {
      System.out.println("data problem");
      e.printStackTrace();
      for (int i = 0; i < clusterCount; i++) {
        expressionAverages[multigeneIndex][i] = (float) Math.random();
        expressionSDs[multigeneIndex][i] = (float) Math.random() / 10f;
      }
    }
  }
Beispiel #7
0
  /** Initialize the algorithm's parameters and execute it. */
  public DefaultMutableTreeNode execute(IFramework framework) throws AlgorithmException {
    this.framework = framework;
    this.experiment = framework.getData().getExperiment();
    this.iData = framework.getData();

    Listener listener = new Listener();

    try {

      DAMInitDialog damInitDialog = new DAMInitDialog(framework.getFrame(), true);

      if (damInitDialog.showModal() != JOptionPane.OK_OPTION) {
        return null;
      }

      classifyGenes = damInitDialog.isEvaluateGenesSelected();
      algorithmSelection = damInitDialog.getAssessmentSelection();
      isPDA = damInitDialog.isPDASelected();
      numberOfClasses = damInitDialog.getNumClasses();
      kValue = damInitDialog.getKValue();
      alpha = damInitDialog.getAlphaValue();

      preSelectGenes = !(damInitDialog.getSkipGeneSelectionValue());

      DAMClassificationEditor damClassEditor =
          new DAMClassificationEditor(framework, classifyGenes, numberOfClasses);
      damClassEditor.setVisible(true);

      while (!damClassEditor.isNextPressed()) {
        if (damClassEditor.isCancelPressed()) {
          return null;
        } else {
          continue;
        }
      }

      AlgorithmData data = new AlgorithmData();

      boolean useGenes = damInitDialog.isEvaluateGenesSelected();
      if (useGenes) {
        mode = 1;
        data.addParam("dam-mode", "1");
      } else {
        mode = 3;
        data.addParam("dam-mode", "3");
      }

      classificationVector = damClassEditor.getClassification();
      trainingIndices = new int[classificationVector[0].size()];
      classes = new int[classificationVector[1].size()];
      testIndices = new int[classificationVector[2].size()];

      for (int i = 0; i < trainingIndices.length; i++) {
        trainingIndices[i] = ((Integer) (classificationVector[0].get(i))).intValue();
        classes[i] = ((Integer) (classificationVector[1].get(i))).intValue();
      }

      for (int i = 0; i < testIndices.length; i++) {
        testIndices[i] = ((Integer) (classificationVector[2].get(i))).intValue();
      }

      algorithm = framework.getAlgorithmFactory().getAlgorithm("DAM");
      algorithm.addAlgorithmListener(listener);

      logger = new Logger(framework.getFrame(), "DAM Log Window", listener);
      logger.show();
      logger.append("Starting DAM calculation\n");

      FloatMatrix Cov;
      Experiment experiment = framework.getData().getExperiment();

      if (classifyGenes) {
        // Problem here: if the program has a gene cluster (maybe also if it
        // has an experiment cluster) the matrix returned is null.
        FloatMatrix temp;
        temp = (experiment.getMatrix()).transpose();
        //                System.out.println("floatmatrix size: " + temp.m + ", " + temp.n);
        data.addMatrix("experiment", temp);

      } else {
        data.addMatrix("experiment", experiment.getMatrix());
      }

      data.addParam("distance-factor", String.valueOf(1.0f));
      IDistanceMenu menu = framework.getDistanceMenu();
      data.addParam("distance-absolute", String.valueOf(menu.isAbsoluteDistance()));

      data.addParam("algorithmSelection", String.valueOf(algorithmSelection));
      data.addParam("isPDA", String.valueOf(isPDA));
      data.addParam("preSelectGenes", String.valueOf(preSelectGenes));
      data.addParam("numberOfClasses", String.valueOf(numberOfClasses));
      data.addParam("kValue", String.valueOf(kValue));
      data.addParam("alpha", String.valueOf(alpha));

      data.addIntArray("trainingIndices", trainingIndices);
      data.addIntArray("classes", classes);
      data.addIntArray("testIndices", testIndices);

      int function = menu.getDistanceFunction();
      if (function == Algorithm.DEFAULT) {
        function = Algorithm.COVARIANCE;
      }
      data.addParam("distance-function", String.valueOf(function));
      data.addParam("dam-mode", String.valueOf(mode));

      AlgorithmData result = null;
      DefaultMutableTreeNode node = null;
      long start = System.currentTimeMillis();
      switch (mode) {
        case 1: // Spots
          data.addParam("distance-function", String.valueOf(function));
          result = algorithm.execute(data);
          matrixS = result.getMatrix("S");
          matrix3D = result.getMatrix("matrix3D");
          usedGeneIndices = result.getIntArray("usedGeneIndices");
          unusedGeneIndices = result.getIntArray("unusedGeneIndices");
          node = new DefaultMutableTreeNode("DAM - genes");
          break;
        case 3: // Experiments
          result = algorithm.execute(data);
          matrixS = result.getMatrix("S");
          matrix3D = result.getMatrix("matrix3D");
          usedGeneIndices = result.getIntArray("usedGeneIndices");
          unusedGeneIndices = result.getIntArray("unusedGeneIndices");

          /*
                      if (preSelectGenes) {
                          System.out.println("DAMGUI.java: usedGeneIndices size: " + usedGeneIndices.length);
                          for(int i=0; i< usedGeneIndices.length; i++) {
                              System.out.print(usedGeneIndices[i] + ", ");
                          }
                          System.out.println(" ");
                          System.out.println(" ");
                          System.out.println("DAMGUI.java: unusedGeneIndices size: " + unusedGeneIndices.length);
                          for(int i=0; i< unusedGeneIndices.length; i++) {
                              System.out.print(unusedGeneIndices[i] + ", ");
                          }
                          System.out.println(" ");
                          System.out.println(" ");
                      }
          */

          node = new DefaultMutableTreeNode("DAM - samples");
          break;
        default:
          break;
      }

      Cluster result_cluster = result.getCluster("cluster");
      NodeList nodeList = result_cluster.getNodeList();

      int k = numberOfClasses * 3;
      this.clusters = new int[k][];

      //          System.out.println(" ");
      for (int i = 0; i < k; i++) {
        clusters[i] = nodeList.getNode(i).getFeaturesIndexes();
      }

      Cluster gene_cluster = result.getCluster("geneCluster");
      nodeList = gene_cluster.getNodeList();

      this.geneClusters = new int[2][];

      //          System.out.println(" ");
      for (int i = 0; i < 2; i++) {
        geneClusters[i] = nodeList.getNode(i).getFeaturesIndexes();
      }

      this.means = result.getMatrix("clusters_means");
      this.variances = result.getMatrix("clusters_variances");

      this.means_used = result.getMatrix("clusters_means_used");
      this.variances_used = result.getMatrix("clusters_variances_used");

      this.means_unused = result.getMatrix("clusters_means_unused");
      this.variances_unused = result.getMatrix("clusters_variances_unused");

      columns = new int[(experiment.getMatrix()).getColumnDimension()];
      for (int i = 0; i < columns.length; i++) {
        columns[i] = i;
      }

      rows = new int[(experiment.getMatrix()).getRowDimension()];
      for (int i = 0; i < rows.length; i++) {
        rows[i] = i;
      }

      if (classifyGenes) {
        usedExperiment =
            new Experiment(
                (experiment.getMatrix()).getMatrix(rows, usedGeneIndices), usedGeneIndices, rows);
        unusedExperiment =
            new Experiment(
                (experiment.getMatrix()).getMatrix(rows, unusedGeneIndices),
                unusedGeneIndices,
                rows);
      } else {
        usedExperiment =
            new Experiment(
                (experiment.getMatrix()).getMatrix(usedGeneIndices, columns),
                columns,
                usedGeneIndices);
        unusedExperiment =
            new Experiment(
                (experiment.getMatrix()).getMatrix(unusedGeneIndices, columns),
                columns,
                unusedGeneIndices);
      }

      /*
                     System.out.println("DAMGUI.java - means: " + means.getRowDimension() + " X " + means.getColumnDimension());
                     System.out.println("DAMGUI.java - variances: " + variances.getRowDimension() + " X " + variances.getColumnDimension());

                     System.out.println("DAMGUI.java - matrix3D " + matrix3D.getRowDimension() + " X " + matrix3D.getColumnDimension());
                     for(int i=0; i< matrix3D.getRowDimension(); i++) {
                         for(int j=0; j< matrix3D.getColumnDimension(); j++) {
                             System.out.print(matrix3D.get(i, j) + ", ");
                         }
                         System.out.println(" ");
                     }
      */

      logger.append("Creating the result viewers\n");
      long time = System.currentTimeMillis() - start;
      if (algorithmSelection == A3) // only classification
      addClassificationResultNodes(
            framework.getFrame(), node, time, menu.getFunctionName(function), experiment);
      else
        addValidationResultNodes(
            framework.getFrame(), node, time, menu.getFunctionName(function), experiment);

      return node;
    } finally {
      if (algorithm != null) {
        algorithm.removeAlgorithmListener(listener);
      }
      if (logger != null) {
        logger.dispose();
      }
    }
  }