@Override
  public void execute() {

    List<String> values = null;

    // init
    //
    test = commandLine.getOptionValue("test", null);
    className = commandLine.getOptionValue("class-name", null);
    values =
        (commandLine.hasOption("class-values")
            ? StringUtils.toList(commandLine.getOptionValue("class-values", null), ",")
            : null);
    correction = commandLine.getOptionValue("correction", "fdr");
    String pValueParam = commandLine.getOptionValue("p-value", "0.05");
    String foldChangeValueParam = commandLine.getOptionValue("fold-change-value", "2");
    String datasetParam = commandLine.getOptionValue("dataset");

    if (className != null) {
      if (values == null) {
        values = ListUtils.unique(dataset.getVariables().getByName(className).getValues());
      } else {
        values = ListUtils.unique(values);
      }

      classValues = new ArrayList<String>();
      for (String val : values) {
        if (val != null && val.trim().length() > 0) {
          classValues.add(val.trim());
        }
      }
    }

    if ("fold-change".equalsIgnoreCase(test) || "fold_change".equalsIgnoreCase(test)) {
      try {
        foldChangeValue = Double.parseDouble(foldChangeValueParam);
      } catch (NumberFormatException e) {
        foldChangeValue = 0.05;
      }
    } else {
      try {
        pValue = Double.parseDouble(pValueParam);
        if (pValue > 1 || pValue < 0) {
          pValue = 0.05;
        }
      } catch (NumberFormatException e) {
        pValue = 0.05;
      }
    }

    // input parameters
    //
    result.addOutputItem(
        new Item(
            "dataset_input_param",
            (datasetParam == null ? "" : new File(datasetParam).getName()),
            "Dataset file name",
            Item.TYPE.MESSAGE,
            Arrays.asList("INPUT_PARAM"),
            new HashMap<String, String>(),
            "Input parameters"));
    result.addOutputItem(
        new Item(
            "test_input_param",
            test,
            "Test",
            Item.TYPE.MESSAGE,
            Arrays.asList("INPUT_PARAM"),
            new HashMap<String, String>(),
            "Input parameters"));
    result.addOutputItem(
        new Item(
            "class_input_param",
            (className == null ? "" : className)
                + " ["
                + ListUtils.toString(classValues, ", ")
                + "]",
            "Class",
            Item.TYPE.MESSAGE,
            Arrays.asList("INPUT_PARAM"),
            new HashMap<String, String>(),
            "Input parameters"));
    if ("fold_change".equalsIgnoreCase(test) || "fold-change".equalsIgnoreCase(test)) {
      result.addOutputItem(
          new Item(
              "fold_change_value_input_param",
              foldChangeValueParam,
              "Fold-change value",
              Item.TYPE.MESSAGE,
              Arrays.asList("INPUT_PARAM"),
              new HashMap<String, String>(),
              "Input parameters"));
    } else {
      result.addOutputItem(
          new Item(
              "correction_input_param",
              correction,
              "Multiple-test correction",
              Item.TYPE.MESSAGE,
              Arrays.asList("INPUT_PARAM"),
              new HashMap<String, String>(),
              "Input parameters"));
      result.addOutputItem(
          new Item(
              "pvalue_input_param",
              pValueParam,
              "Adjusted p-value",
              Item.TYPE.MESSAGE,
              Arrays.asList("INPUT_PARAM"),
              new HashMap<String, String>(),
              "Input parameters"));
    }

    // check input parameters
    //
    if (datasetParam == null) {
      abort(
          "missingdataset_execute_classcomparison",
          "Missing dataset",
          "Missing dataset",
          "Missing dataset");
    }

    if (className == null) {
      abort(
          "classnamemissing_execute_classcomparison",
          "class name missing",
          "class name missing",
          "class name missing");
    }

    if (classValues == null) {
      abort(
          "classvaluesmissing_execute_classcomparison",
          "class values missing",
          "class values missing",
          "class values missing");
    }

    if (test == null) {
      abort(
          "testmissing_execute_classcomparison",
          "class comparison test missing",
          "class comparison test missing",
          "class comparison test missing");
    }

    // reading dataset
    //
    File datasetFile = new File(datasetParam);
    try {
      dataset = new Dataset(datasetFile);
      if (!dataset.load() && !dataset.validate()) {
        abort(
            "exception_execute_classcomparison",
            "Error",
            "Error loading dataset "
                + datasetFile.getName()
                + ": "
                + dataset.getMessages().getErrorString(""),
            "");
      }
    } catch (Exception e) {
      abort(
          "exception_execute_clustering",
          "Error",
          "Error reading dataset " + datasetFile.getName(),
          "");
    }

    // executing test
    //
    updateJobStatus("40", "computing " + test);
    if ("limma".equalsIgnoreCase(test)) {
      executeLimma();
    } else if ("t".equalsIgnoreCase(test)) {
      if (classValues.size() == 2) {
        executeT();
      } else {
        abort(
            "testmismatched_execute_classcomparison",
            "test " + test + " not supported for " + classValues.size() + "-class test",
            "test " + test + " not supported for " + classValues.size() + "-class test",
            "test " + test + " not supported for " + classValues.size() + "-class test");
      }
    } else if ("fold_change".equalsIgnoreCase(test) || "fold-change".equalsIgnoreCase(test)) {

      if (classValues.size() == 2) {
        executeFoldChange();
      } else {
        abort(
            "testmismatched_execute_classcomparison",
            "test " + test + " not supported for " + classValues.size() + "-class test",
            "test " + test + " not supported for " + classValues.size() + "-class test",
            "test " + test + " not supported for " + classValues.size() + "-class test");
      }
    } else if ("anova".equalsIgnoreCase(test)) {
      if (classValues.size() > 2) {
        executeAnova();
      } else {
        abort(
            "testmismatched_execute_classcomparison",
            "test " + test + " not supported for " + classValues.size() + "-class test",
            "test " + test + " not supported for " + classValues.size() + "-class test",
            "test " + test + " not supported for " + classValues.size() + "-class test");
      }
    } else {
      abort(
          "testunknown_execute_classcomparison",
          "unknown test " + test,
          "unknown test " + test,
          "unknown test " + test);
    }
  }
Exemple #2
0
  public LayoutResp layout(
      String layoutAlgorithm,
      String outputFormat,
      String dotData,
      String filename,
      String base64,
      String jsonpCallback) {
    LayoutResp resp = new LayoutResp();

    logger.debug("LayoutWSServer: layout() method");
    if (graphvizLayoutAlgorithms.contains(layoutAlgorithm)) {
      if (graphvizOutputFormats.containsKey(outputFormat)) {
        if (dotData != null && !dotData.equals("")) {
          logger.debug(
              "Algorithm layout: "
                  + layoutAlgorithm
                  + ", output format: "
                  + outputFormat
                  + ", dot: "
                  + dotData);
          try {
            logger.info("defaultConfig:" + config.toString());
            String randomFolder =
                config.getProperty("TMP.FOLDER") + "/" + StringUtils.randomString(20) + "_layout";
            logger.debug("Creating output folder: " + randomFolder);
            FileUtils.createDirectory(randomFolder);

            String inputFile = randomFolder + "/input.dot";
            String outputFile = randomFolder + "/" + filename + "." + outputFormat;
            logger.debug("Writting dot data file: " + inputFile);
            IOUtils.write(inputFile, dotData);

            int exitValue =
                executeGraphviz(
                    new File(inputFile), layoutAlgorithm, outputFormat, new File(outputFile));
            if (exitValue == 0) {
              FileUtils.checkFile(outputFile);
              if (base64 != null && base64.trim().equalsIgnoreCase("true")) {
                logger.debug("Encoding in Base64 the dot output file...");
                byte[] binaryBytes = toByteArray(new FileInputStream(outputFile));
                byte[] base64Bytes = Base64.encodeBase64(binaryBytes);
                String encodedString = new String(base64Bytes);

                if (jsonpCallback != null && !jsonpCallback.equals("")) {
                  //									return Response.ok("var " + jsonpCallback + " = (" + encodedString +
                  // ")", MediaType.APPLICATION_JSON_TYPE).build();
                  resp.setData("var " + jsonpCallback + " = (" + encodedString + ")");
                  resp.setType("json");
                  return resp;
                } else {
                  //									return Response.ok(encodedString,
                  // MediaType.TEXT_PLAIN).header("content-disposition","attachment; filename =
                  // "+filename+"."+outputFormat).build();
                  //									return Response.ok(encodedString, MediaType.TEXT_PLAIN).build();
                  resp.setData(encodedString);
                  resp.setType("text");
                  return resp;
                }
              } else {
                // returning the Graphviz output file
                byte[] bytes = toByteArray(new FileInputStream(new File(outputFile)));
                //								return Response.ok(bytes,
                // MediaType.APPLICATION_OCTET_STREAM).header("content-disposition","attachment;
                // filename = "+filename+"."+outputFormat).build();
                //								return createOkResponse(bytes, MediaType.APPLICATION_OCTET_STREAM_TYPE,
                // filename+"."+outputFormat);
                resp.setData(bytes);
                resp.setType("bytes");
                resp.setFileName(filename + "." + outputFormat);
                return resp;
              }
            } else {
              //							return Response.ok("Graphviz exit status not 0: '"+exitValue+"'",
              // MediaType.TEXT_PLAIN).header("content-disposition","attachment; filename =
              // "+filename+".err.log").build();
              //							return createOkResponse("Graphviz exit status not 0: '"+exitValue+"'",
              // MediaType.TEXT_PLAIN_TYPE, filename+".err.log");
              resp.setData("Graphviz exit status not 0: '" + exitValue + "'");
              resp.setType("text");
              resp.setFileName(filename + ".err.log");
              return resp;
            }
          } catch (Exception e) {
            logger.error(
                "Error in LayoutWSServer, layout() method: " + StringUtils.getStackTrace(e));
            if (base64 != null && base64.trim().equalsIgnoreCase("true")) {
              //							return Response.ok("Error in LayoutWSServer, layout()
              // method:\n"+StringUtils.getStackTrace(e), MediaType.TEXT_PLAIN).build();
              //							return createOkResponse("Error in LayoutWSServer, layout()
              // method:\n"+StringUtils.getStackTrace(e), MediaType.TEXT_PLAIN_TYPE);
              resp.setData(
                  "Error in LayoutWSServer, layout() method:\n" + StringUtils.getStackTrace(e));
              resp.setType("text");
              return resp;
            } else {
              //							return Response.ok("Error in LayoutWSServer, layout()
              // method:\n"+StringUtils.getStackTrace(e),
              // MediaType.TEXT_PLAIN).header("content-disposition","attachment; filename =
              // "+filename+".err.log").build();
              //							return createOkResponse("Error in LayoutWSServer, layout()
              // method:\n"+StringUtils.getStackTrace(e), MediaType.TEXT_PLAIN_TYPE,
              // filename+".err.log");
              resp.setData(
                  "Error in LayoutWSServer, layout() method:\n" + StringUtils.getStackTrace(e));
              resp.setType("text");
              resp.setFileName(filename + ".err.log");
              return resp;
            }
          }
        } else {
          if (base64 != null && base64.trim().equalsIgnoreCase("true")) {
            //						return Response.ok("dot data '"+dotData+"' is not valid",
            // MediaType.TEXT_PLAIN).build();
            //						return createOkResponse("dot data '"+dotData+"' is not valid",
            // MediaType.TEXT_PLAIN_TYPE);
            resp.setData("dot data '" + dotData + "' is not valid");
            resp.setType("text");
            return resp;
          } else {
            //						return Response.ok("dot data '"+dotData+"' is not valid",
            // MediaType.TEXT_PLAIN).header("content-disposition","attachment; filename =
            // "+filename+".err.log").build();
            //						return createOkResponse("dot data '"+dotData+"' is not valid",
            // MediaType.TEXT_PLAIN_TYPE, filename+".err.log");
            resp.setData("dot data '" + dotData + "' is not valid");
            resp.setType("text");
            resp.setFileName(filename + ".err.log");
            return resp;
          }
        }
      } else {
        if (base64 != null && base64.trim().equalsIgnoreCase("true")) {
          //					return Response.ok("Format '"+outputFormat+"' is not valid",
          // MediaType.TEXT_PLAIN).build();
          //					return createOkResponse("Format '"+outputFormat+"' is not valid",
          // MediaType.TEXT_PLAIN_TYPE);
          resp.setData("Format '" + outputFormat + "' is not valid");
          resp.setType("text");
          return resp;
        } else {
          //					return Response.ok("Format '"+outputFormat+"' is not valid",
          // MediaType.TEXT_PLAIN).header("content-disposition","attachment; filename =
          // "+filename+".err.log").build();
          //					return createOkResponse("Format '"+outputFormat+"' is not valid",
          // MediaType.TEXT_PLAIN_TYPE, filename+".err.log");
          resp.setData("Format '" + outputFormat + "' is not valid");
          resp.setType("text");
          resp.setFileName(filename + ".err.log");
          return resp;
        }
      }
    } else {
      if (base64 != null && base64.trim().equalsIgnoreCase("true")) {
        //				return Response.ok("Algorithm '"+layoutAlgorithm+"' is not valid",
        // MediaType.TEXT_PLAIN).build();
        //				return createOkResponse("Algorithm '"+layoutAlgorithm+"' is not valid",
        // MediaType.TEXT_PLAIN_TYPE);
        resp.setData("Algorithm '" + layoutAlgorithm + "' is not valid");
        resp.setType("text");
        return resp;
      } else {
        //				return Response.ok("Algorithm '"+layoutAlgorithm+"' is not valid",
        // MediaType.TEXT_PLAIN).header("content-disposition","attachment; filename =
        // "+filename+".err.log").build();
        //				return createOkResponse("Algorithm '"+layoutAlgorithm+"' is not valid",
        // MediaType.TEXT_PLAIN_TYPE, filename+".err.log");
        resp.setData("Algorithm '" + layoutAlgorithm + "' is not valid");
        resp.setType("text");
        resp.setFileName(filename + ".err.log");
        return resp;
      }
    }
  }
  private void setFoldChangeResults(
      Dataset subDataset, String test, String testLabel, double[] res, String className)
      throws InvalidIndexException, IOException {

    //		int[] columnOrder =
    // ListUtils.order(subDataset.getVariables().getByName(className).getValues());
    int[] rowOrder = ListUtils.order(ArrayUtils.toList(res), true);

    DataFrame dataFrame = new DataFrame(subDataset.getFeatureNames().size(), 0);
    dataFrame.addColumn(test, ListUtils.ordered(ArrayUtils.toStringList(res), rowOrder));
    dataFrame.setRowNames(ListUtils.ordered(subDataset.getFeatureNames(), rowOrder));

    FeatureData featureData = new FeatureData(dataFrame);
    File file = new File(outdir + "/" + test + "_foldchange.txt");
    IOUtils.write(file, dataFrame.toString(true, true));

    /** Get significative terms, babelomics 5 * */
    List<String> featureNames = new ArrayList<String>();
    List<String> featureValues = new ArrayList<String>();

    List<String> featureNamesUp = new ArrayList<String>();
    List<String> featureNamesDown = new ArrayList<String>();

    for (String rowName : dataFrame.getRowNames()) {
      List<String> row = dataFrame.getRow(rowName);
      double stats = Double.parseDouble(row.get(0));
      if (Math.abs(stats) >= foldChangeValue) {
        featureNames.add(rowName);
        featureValues.add(row.get(0));
        if (stats >= 0) featureNamesUp.add(rowName);
        else featureNamesDown.add(rowName);
      }
    }

    dataFrame = new DataFrame(featureNames.size(), 0);
    dataFrame.addColumn(test, featureValues);
    dataFrame.setRowNames(featureNames);

    List<Integer> sigRowIndexes = new ArrayList<Integer>();
    for (String feat : featureNames) {
      int idx = 0;
      for (String featSub : subDataset.getFeatureNames()) {
        if (feat.equalsIgnoreCase(featSub)) sigRowIndexes.add(idx);
        idx++;
      }
    }
    DoubleMatrix doubleMatrix =
        new DoubleMatrix(dataFrame.getRowDimension(), subDataset.getColumnDimension());
    for (int i = 0; i < sigRowIndexes.size(); i++) {
      doubleMatrix.setRow(i, subDataset.getDoubleMatrix().getRow(sigRowIndexes.get(i)));
    }
    File fileXX = new File(outdir + "/" + test + "_foldchange_significative_dataset.txt");
    Dataset sigDataset = new Dataset(subDataset.getSampleNames(), featureNames, doubleMatrix);
    sigDataset.save(fileXX);

    File fileAux = new File(outdir + "/" + test + "_foldchange_significative_table.txt");
    IOUtils.write(fileAux, dataFrame.toString(true, true));

    fileAux = new File(outdir + "/" + test + "_foldchange_significative_table_up.txt");
    IOUtils.write(fileAux, featureNamesUp);

    fileAux = new File(outdir + "/" + test + "_foldchange_significative_table_down.txt");
    IOUtils.write(fileAux, featureNamesDown);

    //        fileAux = new File(outdir + "/" + test + "_foldchange_significative_dataset.txt");
    //        IOUtils.write(fileAux, featureNamesDown);

    //
    //		List<String> featuresUp = new ArrayList<String>();
    //		List<String> featuresDown = new ArrayList<String>();
    //		for (String rowName : dataFrame.getRowNames()) {
    //                List<String> row = dataFrame.getRow(rowName);
    //                double stats = Double.parseDouble(row.get(0));
    //                if(stats>=foldChangeValue){
    //
    //
    ////                    featuresUp.add(rowName);
    ////                else
    ////                    featuresDown.add(rowName);
    //				}
    //            }
    //			file = new File(tool.getOutdir() + "/" + test + "_significative_table_up.txt");
    //			IOUtils.write(file, featuresUp);
    //			file = new File(tool.getOutdir() + "/" + test + "_significative_table_down.txt");
    //			IOUtils.write(file, featuresDown);

    // featureData.save(file);
    if (file.exists()) {
      result.addOutputItem(
          new Item(
              test + "_foldchange",
              file.getName(),
              testLabel + " fold-change output file",
              TYPE.FILE,
              new ArrayList<String>(),
              new HashMap<String, String>(),
              testLabel + " fold-change.Output files"));

      String json =
          "{\\\"paramfilename\\\": \\\"input_params.txt\\\", \\\"testfilename\\\": \\\""
              + file.getName()
              + "\\\"}";
      result.addOutputItem(
          new Item(
              "diff_expr_" + StringUtils.randomString(8),
              json,
              "Significative results",
              TYPE.FILE,
              StringUtils.toList("DIFF_EXPRESSION_VIEWER"),
              new HashMap<String, String>(),
              testLabel + " fold-change. Significative results"));

      DiffExpressionUtils.createFatiScanRedirection(
          dataFrame, test, test, result, outdir, testLabel + " fold-change.");
    }

    /*
    		List<Double> orderedRes = ListUtils.ordered(ArrayUtils.toList(res), rowOrder);
    		int posValues = 0;
    		int negValues = 0;
    		for(int i=0 ; i<orderedRes.size() ; i++) {
    			if (Math.abs(orderedRes.get(i))>foldChangeValue) {
    				if (orderedRes.get(i)>0) {
    					posValues++;
    				} else {
    					negValues++;
    				}
    			}
    		}

    		if (posValues + negValues == 0) {
    			result.addOutputItem(new Item("no_sig_results", "No significative results (fold-change value = " + foldChangeValue + ")", "Significative results", TYPE.MESSAGE, new ArrayList<String>(), new HashMap<String, String>(2), testLabel + " fold-change.Significative results"));
    			return;
    		}

    		int halfDisplay = maxDisplay/2;
    		int posValuesToDisplay = posValues;
    		int negValuesToDisplay = negValues;
    		if (posValues + negValues > maxDisplay) {
    			if (Math.min(posValues, negValues)>halfDisplay) {
    				posValuesToDisplay = halfDisplay;
    				negValuesToDisplay = halfDisplay;
    			} else {
    				posValuesToDisplay = posValues>negValues ? (maxDisplay-negValues) : posValues;
    				negValuesToDisplay = negValues>posValues ? (maxDisplay-posValues) : negValues;
    			}
    		}

    		int nbToDisplay = posValuesToDisplay + negValuesToDisplay;
    		DoubleMatrix doubleMatrix = new DoubleMatrix(nbToDisplay, subDataset.getColumnDimension());
    		int rowIndex = 0;
    		int negLimit = rowOrder.length-negValuesToDisplay;
    		List<Integer> sigRowIndexes = new ArrayList<Integer>();
    		for(int i=0 ; i<rowOrder.length ; i++) {
    			if (i<posValuesToDisplay || i>=negLimit) {
    				doubleMatrix.setRow(rowIndex++, subDataset.getDoubleMatrix().getRow(rowOrder[i]));
    				//System.out.println(subDataset.getFeatureNames().get(sigOrder[i]));
    				sigRowIndexes.add(rowOrder[i]);
    			}
    		}

    		file = new File(outdir + "/" + test +"_fold_change_significative_dataset.txt");
    		Dataset sigDataset = new Dataset(subDataset.getSampleNames(), ListUtils.subList(subDataset.getFeatureNames(), ListUtils.toIntArray(sigRowIndexes)), doubleMatrix);
    		sigDataset.setVariables(subDataset.getVariables());
    		sigDataset.validate();
    		sigDataset.save(file);
    		if (file.exists()) {
    			String tags = "datamatrix,expression";
    			result.addOutputItem(new Item(test + "_sig_dataset", file.getName(), "Significative values dataset (fold-change value = " + foldChangeValue + ")", TYPE.DATA, StringUtils.toList(tags, ","), new HashMap<String, String>(2),  testLabel + " fold-change.Significative results"));

    			File redirectionFile = new File(outdir + "/clustering.redirection");
    			DiffExpressionUtils.createClusteringRedirectionFile(redirectionFile, file);
    			if ( redirectionFile.exists() ) {
    				tags = "REDIRECTION(" + redirectionFile.getName() + ":Send to Clustering tool...)";
    				result.addOutputItem(new Item(test + "_sig_dataset", file.getName(), "Significative values dataset (fold-change value = " + foldChangeValue + ")", TYPE.FILE, StringUtils.toList(tags, ","), new HashMap<String, String>(2),  testLabel + " fold-change.Significative results"));
    			}
    		}

    		rowOrder = ListUtils.order(ListUtils.subList(ArrayUtils.toList(res), ListUtils.toIntArray(sigRowIndexes)), true);

    		DataFrame sigDataFrame = new DataFrame(sigDataset.getFeatureNames().size(), 0);

    		sigDataFrame.addColumn(test, ListUtils.toStringList(ListUtils.ordered(ListUtils.subList(ArrayUtils.toList(res), ListUtils.toIntArray(sigRowIndexes)), rowOrder)));
    		sigDataFrame.setRowNames(ListUtils.ordered(ListUtils.subList(subDataset.getFeatureNames(), ListUtils.toIntArray(sigRowIndexes)), rowOrder));

    		// adding table to results
    		//
    		file = new File(outdir + "/" + test + "fold_change_significative_table.txt");
    		IOUtils.write(file, sigDataFrame.toString(true, true));
    		if ( file.exists() ) {
    			result.addOutputItem(new Item(test + "fold_change_table", file.getName(), "Significative values table (fold-change value = " + foldChangeValue + ")", TYPE.FILE, StringUtils.toList("TABLE," + test.toUpperCase() + "_FOLD_CHANGE_TABLE", ","), new HashMap<String, String>(2), testLabel + " fold-change.Significative results"));
    		}

    		// adding heatmap to results
    		//
    		Canvas sigHeatmap = DiffExpressionUtils.generateHeatmap(sigDataset, className, columnOrder, rowOrder, testLabel, ListUtils.toDoubleArray(ListUtils.subList(ArrayUtils.toList(res), ListUtils.toIntArray(sigRowIndexes))), null, null);
    		if (sigHeatmap == null) {
    			printError("ioexception_execute_fold_change_classcomparison", "ERROR", "Error generating " + test + " fold-change heatmap image");
    		} else {
    			try {
    				File sigHeatmapFile = new File(outdir + "/" + test + "fold_change_heatmap_significative.png");
    				sigHeatmap.save(sigHeatmapFile.getAbsolutePath());
    				if (sigHeatmapFile.exists()) {
    					result.addOutputItem(new Item(test + "_fold_change_heatmap_significative", sigHeatmapFile.getName(), testLabel + " fold-change heatmap with significative values (fold-change value = " + foldChangeValue + ")", TYPE.IMAGE, new ArrayList<String>(2), new HashMap<String, String>(2), testLabel + " fold-change.Significative results"));
    				}
    			} catch (IOException e) {
    				printError("ioexception_execute_fold_change_classcomparison", "ERROR", "Error saving " + test + " fold-change heatmap image");
    			}
    		}
    		DiffExpressionUtils.createFatiGoRedirection(dataFrame.getRowNames(), dataFrame.getColumnAsDoubleArray(test), test, result, outdir, testLabel + " fold-change.");
    		DiffExpressionUtils.createFatiScanRedirection(sigDataFrame, test, test, result, outdir, testLabel + " fold-change.");
    */
  }
Exemple #4
0
  public LayoutResp coordinates(String layoutAlgorithm, String dotData, String jsonpCallback) {
    LayoutResp resp = new LayoutResp();

    logger.debug("LayoutWSServer:  coordinates() method");
    if (graphvizLayoutAlgorithms.contains(layoutAlgorithm)) {
      StringBuilder sb = new StringBuilder("{");
      try {
        String randomFolder =
            config.getProperty("TMP.FOLDER") + "/" + StringUtils.randomString(20) + "_layout";
        logger.debug("Creating output folder: " + randomFolder);
        FileUtils.createDirectory(randomFolder);

        String inputFile = randomFolder + "/input.dot";
        String outputFile = randomFolder + "/output.plain";
        logger.debug("Writting dot data file: " + inputFile);
        IOUtils.write(inputFile, dotData);

        int exitValue =
            executeGraphviz(new File(inputFile), layoutAlgorithm, "plain", new File(outputFile));
        if (exitValue == 0) {
          FileUtils.checkFile(outputFile);
          // getting the coords form the file
          List<String> lines = IOUtils.grep(new File(outputFile), "^node.+");
          String[] fields;
          double min = Double.POSITIVE_INFINITY;
          double max = Double.NEGATIVE_INFINITY;
          String[] ids = new String[lines.size()];
          double[][] coords = new double[lines.size()][2];
          for (int i = 0; i < lines.size(); i++) {
            fields = lines.get(i).split(" ");
            ids[i] = fields[1];
            coords[i][0] = Double.parseDouble(fields[2]);
            coords[i][1] = Double.parseDouble(fields[3]);
            min = Math.min(min, Math.min(coords[i][0], coords[i][1]));
            max = Math.max(max, Math.max(coords[i][0], coords[i][1]));
          }
          // max needs to be calculated after subtract min
          max -= min;
          for (int i = 0; i < ids.length; i++) {
            sb.append("\"" + ids[i] + "\"")
                .append(": {")
                .append("\"id\":\"")
                .append(ids[i])
                .append("\", \"x\": ")
                .append((coords[i][0] - min) / max)
                .append(", \"y\": ")
                .append((coords[i][1] - min) / max)
                .append("}");
            if (i < ids.length - 1) {
              sb.append(", ");
            }
          }
          sb.append("}");

          if (jsonpCallback != null && !jsonpCallback.equals("")) {
            //						return Response.ok("var " + jsonpCallback + " = (" + sb.toString() + ")",
            // MediaType.APPLICATION_JSON_TYPE).build();
            //						return createOkResponse("var " + jsonpCallback + " = (" + sb.toString() + ")",
            // MediaType.APPLICATION_JSON_TYPE);
            resp.setData("var " + jsonpCallback + " = (" + sb.toString() + ")");
            resp.setType("json");
            return resp;
          } else {
            //						return Response.ok(sb.toString(), MediaType.TEXT_PLAIN).build();
            //						return createOkResponse(sb.toString(), MediaType.TEXT_PLAIN_TYPE);
            resp.setData(sb.toString());
            resp.setType("text");
            return resp;
          }
        } else {
          //					return Response.ok("Graphviz exit status not 0: '"+exitValue+"'",
          // MediaType.TEXT_PLAIN).build();
          //					return createOkResponse("Graphviz exit status not 0: '"+exitValue+"'",
          // MediaType.TEXT_PLAIN_TYPE);
          resp.setData("Graphviz exit status not 0: '" + exitValue + "'");
          resp.setType("text");
          return resp;
        }
      } catch (Exception e) {
        logger.error("Error in LayoutWSServer, layout() method: " + StringUtils.getStackTrace(e));
        //				return Response.ok("Error in LayoutWSServer, coordinates()
        // method:\n"+StringUtils.getStackTrace(e), MediaType.TEXT_PLAIN).build();
        //				return createOkResponse("Error in LayoutWSServer, coordinates()
        // method:\n"+StringUtils.getStackTrace(e), MediaType.TEXT_PLAIN_TYPE);
        resp.setData(
            "Error in LayoutWSServer, coordinates() method:\n" + StringUtils.getStackTrace(e));
        resp.setType("text");
        return resp;
      }
    } else {
      //			return Response.ok("Algorithm '"+layoutAlgorithm+"' is not valid",
      // MediaType.TEXT_PLAIN).build();
      //			return createOkResponse("Algorithm '"+layoutAlgorithm+"' is not valid",
      // MediaType.TEXT_PLAIN_TYPE);
      resp.setData("Algorithm '" + layoutAlgorithm + "' is not valid");
      resp.setType("text");
      return resp;
    }
  }