/** Starts the program. */
  public void runAlgorithm() {
    int i, j, k;

    if (srcImage == null) {
      displayError("Source Image is null");
      finalize();

      return;
    }

    if (threadStopped) {
      finalize();

      return;
    }

    trueVOIs = srcImage.getVOIs();
    nTrueVOIs = trueVOIs.size();
    testVOIs = testImage.getVOIs();
    nTestVOIs = testVOIs.size();
    length = srcImage.getExtents()[0];

    for (i = 1; i < srcImage.getNDims(); i++) {
      length *= srcImage.getExtents()[i];
    }

    testLength = testImage.getExtents()[0];

    for (i = 1; i < testImage.getNDims(); i++) {
      testLength *= testImage.getExtents()[i];
    }

    if (length != testLength) {
      MipavUtil.displayError(
          srcImage.getImageName()
              + " and "
              + testImage.getImageName()
              + " are unequal in dimensions");
      setCompleted(false);

      return;
    }

    trueMask = new short[length];
    testMask = new short[length];
    ViewUserInterface.getReference().setGlobalDataText(srcImage.getImageName() + " = true\n");
    ViewUserInterface.getReference().setGlobalDataText(testImage.getImageName() + " = test\n");

    for (i = 0; i < nTrueVOIs; i++) {

      if ((trueVOIs.VOIAt(i).getCurveType() == VOI.CONTOUR)
          || (trueVOIs.VOIAt(i).getCurveType() == VOI.POLYLINE)) {
        trueID = trueVOIs.VOIAt(i).getID();

        for (j = 0; j < nTestVOIs; j++) {
          testID = testVOIs.VOIAt(j).getID();

          if (trueID == testID) {

            for (k = 0; k < length; k++) {
              trueMask[k] = -1;
              testMask[k] = -1;
            }

            trueMask = srcImage.generateVOIMask(trueMask, i);
            testMask = testImage.generateVOIMask(testMask, j);
            absoluteTrue = 0;
            trueFound = 0;
            falseNegative = 0;
            falsePositive = 0;

            for (k = 0; k < length; k++) {

              if (trueMask[k] == trueID) {
                absoluteTrue++;

                if (testMask[k] == trueID) {
                  trueFound++;
                } else {
                  falseNegative++;
                }
              } // if (trueMask[k] == trueID)
              else { // trueMask[k] != trueID

                if (testMask[k] == trueID) {
                  falsePositive++;
                }
              } // else trueMask[k] != trueID
            } // for (k = 0; k < length; k++)

            ViewUserInterface.getReference()
                .setGlobalDataText(
                    "Statistics for VOIs with ID = " + String.valueOf(trueID) + "\n");
            fnvf = (float) falseNegative / (float) absoluteTrue;
            ViewUserInterface.getReference()
                .setGlobalDataText(
                    "     False negative volume fraction = " + String.valueOf(fnvf) + "\n");
            fpvf = (float) falsePositive / (float) absoluteTrue;
            ViewUserInterface.getReference()
                .setGlobalDataText(
                    "     False positive volume fraction = " + String.valueOf(fpvf) + "\n");
            tpvf = (float) trueFound / (float) absoluteTrue;
            ViewUserInterface.getReference()
                .setGlobalDataText(
                    "     True Positive volume fraction = " + String.valueOf(tpvf) + "\n\n");
          } // if (trueID == testID)
        } // for (j = 0; j < nTestVOIs; j++)
      } // if ((trueVOIs.VOIAt(i).getCurveType() == VOI.CONTOUR)
    } // for (i = 0; i < nTrueVOIs; i++)

    setCompleted(true);
  }
  /**
   * Initializes the GUI by creating the components, placing them in the dialog, and displaying
   * them.
   */
  private void init() {
    setForeground(Color.black);

    setTitle("Nonlocal Means Filter");

    JPanel mainPanel;
    mainPanel = new JPanel();
    mainPanel.setBorder(BorderFactory.createEmptyBorder(3, 3, 3, 3));
    mainPanel.setLayout(new GridBagLayout());

    GridBagConstraints gbc = new GridBagConstraints();
    gbc.gridwidth = 1;
    gbc.gridheight = 1;
    gbc.anchor = GridBagConstraints.WEST;
    gbc.weightx = 1;
    gbc.insets = new Insets(3, 3, 3, 3);
    gbc.gridx = 0;
    gbc.gridy = 0;
    gbc.fill = GridBagConstraints.HORIZONTAL;

    paramPanel = new JPanel(new GridBagLayout());
    paramPanel.setForeground(Color.black);
    paramPanel.setBorder(buildTitledBorder("Parameters"));
    mainPanel.add(paramPanel, gbc);

    GridBagConstraints gbc2 = new GridBagConstraints();
    gbc2.gridwidth = 1;
    gbc2.gridheight = 1;
    gbc2.anchor = GridBagConstraints.WEST;
    gbc2.weightx = 1;
    gbc2.insets = new Insets(3, 3, 3, 3);
    gbc2.gridx = 0;
    gbc2.gridy = 0;
    gbc2.fill = GridBagConstraints.HORIZONTAL;

    labelSearchWindowSide = createLabel("Search window side (odd)");

    paramPanel.add(labelSearchWindowSide, gbc2);

    gbc2.gridx = 1;
    textSearchWindowSide = createTextField("15");
    paramPanel.add(textSearchWindowSide, gbc2);

    gbc2.gridx = 0;
    gbc2.gridy = 1;
    labelSimilarityWindowSide = createLabel("Similarity window side (odd) ");
    paramPanel.add(labelSimilarityWindowSide, gbc2);

    gbc2.gridx = 1;
    textSimilarityWindowSide = createTextField("7");
    paramPanel.add(textSimilarityWindowSide, gbc2);

    gbc2.gridx = 0;
    gbc2.gridy = 2;
    labelNoiseStandardDeviation = createLabel("Noise standard deviation ");
    paramPanel.add(labelNoiseStandardDeviation, gbc2);

    gbc2.gridx = 1;
    textNoiseStandardDeviation = createTextField("10.0");
    paramPanel.add(textNoiseStandardDeviation, gbc2);

    gbc2.gridx = 0;
    gbc2.gridy = 3;
    labelDegree = createLabel("Degree of filtering ");
    labelDegree.setEnabled(doRician);
    paramPanel.add(labelDegree, gbc2);

    gbc2.gridx = 1;
    textDegree = createTextField("1.414");
    textDegree.setEnabled(doRician);
    paramPanel.add(textDegree, gbc2);

    gbc2.gridx = 0;
    gbc2.gridy = 4;
    doRicianCheckBox = new JCheckBox("Deal with Rician noise in MRI");
    doRicianCheckBox.setFont(serif12);
    doRicianCheckBox.setSelected(false);
    doRicianCheckBox.addActionListener(this);
    paramPanel.add(doRicianCheckBox, gbc2);

    if (image.getNDims() > 2) {
      gbc2.gridx = 0;
      gbc2.gridy = 5;
      gbc2.gridwidth = 2;

      image25DCheckBox = new JCheckBox("Process each slice independently (2.5D)");
      image25DCheckBox.setFont(serif12);
      paramPanel.add(image25DCheckBox, gbc2);
      image25DCheckBox.setSelected(false);
    } // if (image.getNDims > 2)

    JPanel outputOptPanel = new JPanel(new GridLayout(1, 2));
    destinationPanel = new JPanel(new BorderLayout());
    destinationPanel.setForeground(Color.black);
    destinationPanel.setBorder(buildTitledBorder("Destination"));
    outputOptPanel.add(destinationPanel);

    destinationGroup = new ButtonGroup();
    newImage = new JRadioButton("New image", true);
    newImage.setBounds(10, 16, 120, 25);
    newImage.setFont(serif12);
    destinationGroup.add(newImage);
    destinationPanel.add(newImage, BorderLayout.NORTH);

    replaceImage = new JRadioButton("Replace image", false);
    replaceImage.setFont(serif12);
    destinationGroup.add(replaceImage);
    destinationPanel.add(replaceImage, BorderLayout.CENTER);

    // Only if the image is unlocked can it be replaced.
    if (image.getLockStatus() == ModelStorageBase.UNLOCKED) {
      replaceImage.setEnabled(true);
    } else {
      replaceImage.setEnabled(false);
    }

    gbc.gridx = 0;
    gbc.gridy = 1;
    mainPanel.add(outputOptPanel, gbc);

    mainDialogPanel.add(mainPanel, BorderLayout.CENTER);
    mainDialogPanel.add(buildButtons(), BorderLayout.SOUTH);

    getContentPane().add(mainDialogPanel);

    pack();
    setResizable(true);
    // setVisible(true);

    System.gc();
  }
  /**
   * Use the GUI results to set up the variables needed to run the algorithm.
   *
   * @return <code>true</code> if parameters set successfully, <code>false</code> otherwise.
   */
  private boolean setVariables() {
    String tmpStr;

    System.gc();

    if (replaceImage.isSelected()) {
      displayLoc = REPLACE;
    } else if (newImage.isSelected()) {
      displayLoc = NEW;
    }

    tmpStr = textSearchWindowSide.getText();

    if (testParameter(tmpStr, 5, 101)) {
      searchWindowSide = Integer.valueOf(tmpStr).intValue();
    } else {
      MipavUtil.displayError("Search window side must be between 5 and 101");
      textSearchWindowSide.requestFocus();
      textSearchWindowSide.selectAll();

      return false;
    }

    if ((searchWindowSide % 2) == 0) {
      MipavUtil.displayError("Search window side must be an odd number");
      textSearchWindowSide.requestFocus();
      textSearchWindowSide.selectAll();
      return false;
    }

    tmpStr = textSimilarityWindowSide.getText();

    if (testParameter(tmpStr, 3, 99)) {
      similarityWindowSide = Integer.valueOf(tmpStr).intValue();
    } else {
      MipavUtil.displayError("Similarity window side must be between 3 and 99");
      textSimilarityWindowSide.requestFocus();
      textSimilarityWindowSide.selectAll();

      return false;
    }

    if ((similarityWindowSide % 2) == 0) {
      MipavUtil.displayError("Similarity window side must be an odd number");
      textSimilarityWindowSide.requestFocus();
      textSimilarityWindowSide.selectAll();
      return false;
    }

    if (similarityWindowSide >= searchWindowSide) {
      MipavUtil.displayError("Similarity window side must be less than search window side");
      textSimilarityWindowSide.requestFocus();
      textSimilarityWindowSide.selectAll();
      return false;
    }

    tmpStr = textNoiseStandardDeviation.getText();

    if (testParameter(tmpStr, 0.001, 1000.0)) {
      noiseStandardDeviation = Float.valueOf(tmpStr).floatValue();
    } else {
      MipavUtil.displayError("Radius must be between 0.001 and 1000.0");
      textNoiseStandardDeviation.requestFocus();
      textNoiseStandardDeviation.selectAll();

      return false;
    }

    doRician = doRicianCheckBox.isSelected();

    if (doRician) {
      tmpStr = textDegree.getText();
      if (testParameter(tmpStr, 1.0, 10.0)) {
        degreeOfFiltering = Float.valueOf(tmpStr).floatValue();
      } else {
        MipavUtil.displayError("Degree of filtering must be between 1.0 and 10.0");
        textDegree.requestFocus();
        textDegree.selectAll();
      }
    }

    if (image.getNDims() > 2) {
      image25D = image25DCheckBox.isSelected();
    }

    return true;
  }
  /**
   * Once all the necessary variables are set, call the Nonlocal Means filter algorithm based on
   * what type of image this is and whether or not there is a separate destination image.
   */
  protected void callAlgorithm() {
    String name = makeImageName(image.getImageName(), "_NonlocalMeans");
    int[] destExtents;

    if (image.getNDims() == 2) { // source image is 2D
      destExtents = new int[2];
      destExtents[0] = image.getExtents()[0]; // X dim
      destExtents[1] = image.getExtents()[1]; // Y dim
    } else {
      destExtents = new int[3];
      destExtents[0] = image.getExtents()[0];
      destExtents[1] = image.getExtents()[1];
      destExtents[2] = image.getExtents()[2];
    }

    if (displayLoc == NEW) {

      try {

        // Make result image of float type
        if (image.isColorImage()) {
          resultImage = new ModelImage(ModelImage.ARGB, destExtents, name);
        } else {
          resultImage = new ModelImage(ModelImage.FLOAT, destExtents, name);
        }

        // resultImage = (ModelImage)image.clone();
        // resultImage.setImageName(name);
        // Make algorithm
        nlMeansFilterAlgo =
            new AlgorithmNonlocalMeansFilter(
                resultImage,
                image,
                searchWindowSide,
                similarityWindowSide,
                noiseStandardDeviation,
                degreeOfFiltering,
                doRician,
                image25D);

        // This is very important. Adding this object as a listener allows the algorithm to
        // notify this object when it has completed of failed. See algorithm performed event.
        // This is made possible by implementing AlgorithmedPerformed interface
        nlMeansFilterAlgo.addListener(this);
        createProgressBar(image.getImageName(), nlMeansFilterAlgo);

        // Hide dialog
        setVisible(false);

        if (isRunInSeparateThread()) {

          // Start the thread as a low priority because we wish to still have user interface work
          // fast
          if (nlMeansFilterAlgo.startMethod(Thread.MIN_PRIORITY) == false) {
            MipavUtil.displayError("A thread is already running on this object");
          }
        } else {
          nlMeansFilterAlgo.run();
        }
      } catch (OutOfMemoryError x) {
        MipavUtil.displayError("Dialog Nonlocal Means Filter: unable to allocate enough memory");

        if (resultImage != null) {
          resultImage.disposeLocal(); // Clean up memory of result image
          resultImage = null;
        }

        return;
      }
    } else {

      try {

        // No need to make new image space because the user has choosen to replace the source image
        // Make the algorithm class
        nlMeansFilterAlgo =
            new AlgorithmNonlocalMeansFilter(
                null,
                image,
                searchWindowSide,
                similarityWindowSide,
                noiseStandardDeviation,
                degreeOfFiltering,
                doRician,
                image25D);

        // This is very important. Adding this object as a listener allows the algorithm to
        // notify this object when it has completed of failed. See algorithm performed event.
        // This is made possible by implementing AlgorithmedPerformed interface
        nlMeansFilterAlgo.addListener(this);
        createProgressBar(image.getImageName(), nlMeansFilterAlgo);

        // Hide the dialog since the algorithm is about to run.
        setVisible(false);

        // These next lines set the titles in all frames where the source image is displayed to
        // "locked - " image name so as to indicate that the image is now read/write locked!
        // The image frames are disabled and then unregisted from the userinterface until the
        // algorithm has completed.
        Vector<ViewImageUpdateInterface> imageFrames = image.getImageFrameVector();
        titles = new String[imageFrames.size()];

        for (int i = 0; i < imageFrames.size(); i++) {
          titles[i] = ((Frame) (imageFrames.elementAt(i))).getTitle();
          ((Frame) (imageFrames.elementAt(i))).setTitle("Locked: " + titles[i]);
          ((Frame) (imageFrames.elementAt(i))).setEnabled(false);
          userInterface.unregisterFrame((Frame) (imageFrames.elementAt(i)));
        }

        if (isRunInSeparateThread()) {

          // Start the thread as a low priority because we wish to still have user interface work
          // fast
          if (nlMeansFilterAlgo.startMethod(Thread.MIN_PRIORITY) == false) {
            MipavUtil.displayError("A thread is already running on this object");
          }
        } else {
          nlMeansFilterAlgo.run();
        }
      } catch (OutOfMemoryError x) {
        MipavUtil.displayError("Dialog Nonlocal Means Filter: unable to allocate enough memory");

        return;
      }
    }
  }
  /**
   * Use the GUI results to set up the variables needed to run the algorithm.
   *
   * @return <code>true</code> if parameters set successfully, <code>false</code> otherwise.
   */
  private boolean setVariables() {
    String tmpStr;
    int i;

    int totLength = image.getExtents()[0];

    for (i = 1; i < image.getNDims(); i++) {
      totLength *= image.getExtents()[i];
    }

    tmpStr = greenMergingText.getText();
    mergingDistance = Float.parseFloat(tmpStr);
    if (mergingDistance < 0.0f) {
      MipavUtil.displayError("Merging distance cannot be less than 0");
      greenMergingText.requestFocus();
      greenMergingText.selectAll();
      return false;
    }

    tmpStr = redMinText.getText();
    redMin = Integer.parseInt(tmpStr);

    if (redMin < 1) {
      MipavUtil.displayError("red minimum must be at least 1");
      redMinText.requestFocus();
      redMinText.selectAll();

      return false;
    } else if (redMin > totLength) {
      MipavUtil.displayError("red minimum must not exceed " + totLength);
      redMinText.requestFocus();
      redMinText.selectAll();

      return false;
    }

    tmpStr = redFractionText.getText();
    redFraction = Float.parseFloat(tmpStr);

    if (redFraction <= 0.0f) {
      MipavUtil.displayError("red fraction must be greater than zero");
      redFractionText.requestFocus();
      redFractionText.selectAll();

      return false;
    } else if (redFraction > 1.0f) {
      MipavUtil.displayError("red fraction must not exceed one");
      redFractionText.requestFocus();
      redFractionText.selectAll();

      return false;
    }

    tmpStr = greenMinText.getText();
    greenMin = Integer.parseInt(tmpStr);

    if (greenMin < 1) {
      MipavUtil.displayError("green minimum must be at least 1");
      greenMinText.requestFocus();
      greenMinText.selectAll();

      return false;
    } else if (greenMin > totLength) {
      MipavUtil.displayError("green minimum must not exceed " + totLength);
      greenMinText.requestFocus();
      greenMinText.selectAll();

      return false;
    }

    tmpStr = greenFractionText.getText();
    greenFraction = Float.parseFloat(tmpStr);

    if (greenFraction <= 0.0f) {
      MipavUtil.displayError("green fraction must be greater than zero");
      greenFractionText.requestFocus();
      greenFractionText.selectAll();

      return false;
    } else if (greenFraction > 1.0f) {
      MipavUtil.displayError("green fraction must not exceed one");
      greenFractionText.requestFocus();
      greenFractionText.selectAll();

      return false;
    }

    tmpStr = blueMinText.getText();
    blueMin = Integer.parseInt(tmpStr);
    if (blueMin <= 0) {
      MipavUtil.displayError("Number of blue pixels must be greater than 0");
      blueMinText.requestFocus();
      blueMinText.selectAll();
      return false;
    } else if (blueMin > totLength) {
      MipavUtil.displayError("blue minimum must not exceed " + totLength);
      blueMinText.requestFocus();
      blueMinText.selectAll();

      return false;
    }

    if (oneButton.isSelected()) {
      greenRegionNumber = 1;
    } else if (twoButton.isSelected()) {
      greenRegionNumber = 2;
    } else if (threeButton.isSelected()) {
      greenRegionNumber = 3;
    } else {
      greenRegionNumber = 4;
    }

    twoGreenLevels = twoBox.isSelected();

    tmpStr = blueValueText.getText();
    blueBoundaryFraction = Float.parseFloat(tmpStr);
    if (blueBoundaryFraction < 0.0f) {
      MipavUtil.displayError("Blue boundary fraction cannot be less than 0.0");
      blueValueText.requestFocus();
      blueValueText.selectAll();
      return false;
    } else if (blueBoundaryFraction > 1.0f) {
      MipavUtil.displayError("Blue boundary value cannot be greater than 1.0");
      blueValueText.requestFocus();
      blueValueText.selectAll();
      return false;
    }

    blueSmooth = blueSmoothBox.isSelected();

    tmpStr = interpolationText.getText();
    interpolationDivisor = Float.parseFloat(tmpStr);
    if (interpolationDivisor <= 1.0f) {
      MipavUtil.displayError("Interpolation divisor must be greater than 1");
      interpolationText.requestFocus();
      interpolationText.selectAll();
      return false;
    }

    return true;
  } // end setVariables()
  /** Sets up the GUI (panels, buttons, etc) and displays it on the screen. */
  private void init() {
    DecimalFormat df;
    int xUnits;
    String unitStr;
    String distStr;
    setForeground(Color.black);
    setTitle("Center Distances version 2  07/14/08");

    df = new DecimalFormat("0.000E0");

    GridBagConstraints gbc = new GridBagConstraints();
    int yPos = 0;
    gbc.gridwidth = 1;
    gbc.gridheight = 1;
    gbc.anchor = GridBagConstraints.WEST;
    gbc.weightx = 1;
    gbc.insets = new Insets(3, 3, 3, 3);
    gbc.fill = GridBagConstraints.HORIZONTAL;
    gbc.gridx = 0;
    gbc.gridy = yPos++;

    JPanel mainPanel = new JPanel(new GridBagLayout());
    mainPanel.setForeground(Color.black);
    mainPanel.setBorder(buildTitledBorder("Input parameters"));

    blueMinLabel = new JLabel("Minimum number of blue pixels per nucleus");
    blueMinLabel.setForeground(Color.black);
    blueMinLabel.setFont(serif12);
    gbc.gridx = 0;
    gbc.gridy = yPos;
    mainPanel.add(blueMinLabel, gbc);

    blueMinText = new JTextField(5);
    if (image.getNDims() == 2) {
      blueMinText.setText("1000");
    } else {
      blueMinText.setText("20000");
    }
    blueMinText.setFont(serif12);
    gbc.gridx = 1;
    gbc.gridy = yPos++;
    mainPanel.add(blueMinText, gbc);

    redMinLabel = new JLabel("Minimum red pixel count");
    redMinLabel.setForeground(Color.black);
    redMinLabel.setFont(serif12);
    gbc.gridx = 0;
    gbc.gridy = yPos;
    mainPanel.add(redMinLabel, gbc);

    redMinText = new JTextField(5);
    redMinText.setText("50");
    redMinText.setFont(serif12);
    gbc.gridx = 1;
    gbc.gridy = yPos++;
    mainPanel.add(redMinText, gbc);

    redFractionLabel = new JLabel("Fraction of red pixels to consider");
    redFractionLabel.setForeground(Color.black);
    redFractionLabel.setFont(serif12);
    gbc.gridx = 0;
    gbc.gridy = yPos;
    mainPanel.add(redFractionLabel, gbc);

    redFractionText = new JTextField(5);
    redFractionText.setText("0.15");
    redFractionText.setFont(serif12);
    gbc.gridx = 1;
    gbc.gridy = yPos++;
    mainPanel.add(redFractionText, gbc);

    xUnits = image.getFileInfo(0).getUnitsOfMeasure()[0];
    if (xUnits != Unit.UNKNOWN_MEASURE.getLegacyNum()) {
      unitStr = (Unit.getUnitFromLegacyNum(xUnits)).toString();
      greenMergingLabel = new JLabel("Green merging radius around peak (" + unitStr + ")");
    } else {
      greenMergingLabel = new JLabel("Green merging radius around peak");
    }
    greenMergingLabel.setForeground(Color.black);
    greenMergingLabel.setFont(serif12);
    gbc.gridx = 0;
    gbc.gridy = yPos;
    mainPanel.add(greenMergingLabel, gbc);

    if (image.getNDims() == 2) {
      // mergingDistance = 8.0f * image.getFileInfo(0).getResolutions()[0];
      mergingDistance = 0.0f;
    } else {
      // mergingDistance = 4.0f * image.getFileInfo(0).getResolutions()[0];
      mergingDistance = 0.0f;
    }
    distStr = df.format(mergingDistance);
    greenMergingText = new JTextField(10);
    greenMergingText.setText(distStr);
    greenMergingText.setFont(serif12);
    gbc.gridx = 1;
    gbc.gridy = yPos++;
    mainPanel.add(greenMergingText, gbc);

    greenMinLabel = new JLabel("Minimum green pixel count");
    greenMinLabel.setForeground(Color.black);
    greenMinLabel.setFont(serif12);
    gbc.gridx = 0;
    gbc.gridy = yPos;
    mainPanel.add(greenMinLabel, gbc);

    greenMinText = new JTextField(5);
    greenMinText.setText("10");
    greenMinText.setFont(serif12);
    gbc.gridx = 1;
    gbc.gridy = yPos++;
    mainPanel.add(greenMinText, gbc);

    greenFractionLabel = new JLabel("Fraction of green pixels to consider");
    greenFractionLabel.setForeground(Color.black);
    greenFractionLabel.setFont(serif12);
    gbc.gridx = 0;
    gbc.gridy = yPos;
    mainPanel.add(greenFractionLabel, gbc);

    greenFractionText = new JTextField(5);
    greenFractionText.setText("0.01");
    greenFractionText.setFont(serif12);
    gbc.gridx = 1;
    gbc.gridy = yPos++;
    mainPanel.add(greenFractionText, gbc);

    greenRegionsLabel = new JLabel("Green regions per cell");
    greenRegionsLabel.setForeground(Color.black);
    greenRegionsLabel.setFont(serif12);
    gbc.gridx = 0;
    gbc.gridy = yPos;
    mainPanel.add(greenRegionsLabel, gbc);

    JPanel buttonPanel = new JPanel(new GridBagLayout());

    greenGroup = new ButtonGroup();

    oneButton = new JRadioButton("1", false);
    oneButton.setForeground(Color.black);
    oneButton.setFont(serif12);
    greenGroup.add(oneButton);
    gbc.gridx = 0;
    gbc.gridy = 0;
    buttonPanel.add(oneButton, gbc);

    twoButton = new JRadioButton("2", true);
    twoButton.setForeground(Color.black);
    twoButton.setFont(serif12);
    greenGroup.add(twoButton);
    gbc.gridx = 1;
    gbc.gridy = 0;
    buttonPanel.add(twoButton, gbc);

    threeButton = new JRadioButton("3", false);
    threeButton.setForeground(Color.black);
    threeButton.setFont(serif12);
    greenGroup.add(threeButton);
    gbc.gridx = 2;
    gbc.gridy = 0;
    buttonPanel.add(threeButton, gbc);

    fourButton = new JRadioButton("4", false);
    fourButton.setForeground(Color.black);
    fourButton.setFont(serif12);
    greenGroup.add(fourButton);
    gbc.gridx = 3;
    gbc.gridy = 0;
    buttonPanel.add(fourButton, gbc);

    gbc.gridx = 1;
    gbc.gridy = yPos++;
    mainPanel.add(buttonPanel, gbc);

    twoBox = new JCheckBox("Use 2 top gray levels in green segmentation", true);
    twoBox.setForeground(Color.black);
    twoBox.setFont(serif12);
    gbc.gridx = 0;
    gbc.gridy = yPos++;
    mainPanel.add(twoBox, gbc);

    blueValueLabel =
        new JLabel("Fraction of blue transition from image min to max at nucleus boundary");
    blueValueLabel.setForeground(Color.black);
    blueValueLabel.setFont(serif12);
    gbc.gridx = 0;
    gbc.gridy = yPos;
    mainPanel.add(blueValueLabel, gbc);

    blueValueText = new JTextField(5);
    blueValueText.setText("0.15");
    blueValueText.setFont(serif12);
    gbc.gridx = 1;
    gbc.gridy = yPos++;
    mainPanel.add(blueValueText, gbc);

    blueSmoothBox = new JCheckBox("Smooth blue VOI contours with AlgorithmBSmooth", true);
    blueSmoothBox.setForeground(Color.black);
    blueSmoothBox.setFont(serif12);
    blueSmoothBox.addActionListener(this);
    gbc.gridx = 0;
    gbc.gridy = yPos++;
    mainPanel.add(blueSmoothBox, gbc);

    interpolationLabel = new JLabel("Number of interpolation points determined by divisor (> 1.0)");
    interpolationLabel.setForeground(Color.black);
    interpolationLabel.setFont(serif12);
    gbc.gridx = 0;
    gbc.gridy = yPos;
    mainPanel.add(interpolationLabel, gbc);

    interpolationText = new JTextField(5);
    interpolationText.setText("24.0");
    interpolationText.setFont(serif12);
    gbc.gridx = 1;
    gbc.gridy = yPos++;
    mainPanel.add(interpolationText, gbc);

    getContentPane().add(mainPanel, BorderLayout.CENTER);
    getContentPane().add(buildButtons(), BorderLayout.SOUTH);

    pack();
    setVisible(true);
    setResizable(false);
    System.gc();
  } // end init()
Beispiel #7
0
  /** cat. */
  private void cat3D_4D_4D() {

    int length;
    int xDim, yDim;
    float[] buffer;
    int cFactor = 1;
    int i, j;
    float[] resols = new float[3];
    float[] origins = new float[3];
    FileInfoBase[] fileInfo = null;
    FileInfoDicom[] fileInfoDicom = null;
    int srcALength, srcBLength;

    try {
      fireProgressStateChanged(srcImage1.getImageName(), "Concatenating images ...");
      resols = new float[4];
      origins = new float[4];
      xDim = srcImage1.getExtents()[0];
      yDim = srcImage1.getExtents()[1];

      if (srcImage1.isColorImage()) {
        cFactor = 4;
      }

      length = cFactor * xDim * yDim;
      buffer = new float[length];

      int nImages;

      if (srcImage1.getNDims() > srcImage2.getNDims()) {
        nImages =
            (srcImage1.getExtents()[2] * srcImage1.getExtents()[3]) + srcImage2.getExtents()[2];

        for (i = 0;
            (i < (srcImage1.getExtents()[2] * srcImage1.getExtents()[3])) && !threadStopped;
            i++) {
          fireProgressStateChanged(Math.round((float) (i) / (nImages - 1) * 100));

          srcImage1.exportData(i * length, length, buffer);
          destImage.importData(i * length, buffer, false);
        }

        if (threadStopped) {
          buffer = null;
          finalize();

          return;
        }

        for (j = 0; (j < srcImage2.getExtents()[2]) && !threadStopped; j++) {
          fireProgressStateChanged(Math.round((float) (i + j) / (nImages - 1) * 100));

          srcImage2.exportData(j * length, length, buffer);
          destImage.importData((i + j) * length, buffer, false);
        }

        if (threadStopped) {
          buffer = null;
          finalize();

          return;
        }

        destImage.calcMinMax();
      } else {
        nImages =
            (srcImage2.getExtents()[2] * srcImage2.getExtents()[3]) + srcImage1.getExtents()[2];

        for (j = 0; (j < srcImage1.getExtents()[2]) && !threadStopped; j++) {
          fireProgressStateChanged(Math.round((float) (j) / (nImages - 1) * 100));

          srcImage1.exportData(j * length, length, buffer);
          destImage.importData(j * length, buffer, false);
        }

        if (threadStopped) {
          buffer = null;
          finalize();

          return;
        }

        for (i = 0;
            (i < (srcImage2.getExtents()[2] * srcImage2.getExtents()[3])) && !threadStopped;
            i++) {
          fireProgressStateChanged(Math.round((float) (i + j) / (nImages - 1) * 100));

          srcImage2.exportData(i * buffer.length, length, buffer);
          destImage.importData((i + j) * buffer.length, buffer, false);
        }

        if (threadStopped) {
          buffer = null;
          finalize();

          return;
        }

        destImage.calcMinMax();
      }
    } catch (IOException error) {
      buffer = null;
      destImage.disposeLocal(); // Clean up memory of result image
      destImage = null;
      errorCleanUp("Algorithm Concat. Images: Image(s) locked", true);

      return;
    } catch (OutOfMemoryError e) {
      buffer = null;
      destImage.disposeLocal(); // Clean up memory of result image
      destImage = null;
      errorCleanUp("Algorithm Concat. Images: Out of memory", true);

      return;
    }

    resols[0] = srcImage1.getFileInfo()[0].getResolutions()[0];
    resols[1] = srcImage1.getFileInfo()[0].getResolutions()[1];
    resols[2] = srcImage1.getFileInfo()[0].getResolutions()[2];
    resols[3] = srcImage1.getFileInfo()[0].getResolutions()[3];
    origins[0] = srcImage1.getFileInfo()[0].getOrigin()[0];
    origins[1] = srcImage1.getFileInfo()[0].getOrigin()[1];
    origins[2] = srcImage1.getFileInfo()[0].getOrigin()[2];
    origins[3] = srcImage1.getFileInfo()[0].getOrigin()[3];

    if ((srcImage1.getFileInfo()[0] instanceof FileInfoDicom)
        && (srcImage2.getFileInfo()[0] instanceof FileInfoDicom)) {
      fileInfoDicom = new FileInfoDicom[destImage.getExtents()[2] * destImage.getExtents()[3]];

      if (srcImage1.getNDims() > srcImage2.getNDims()) {
        srcALength = srcImage1.getExtents()[2] * srcImage1.getExtents()[3];

        for (i = 0; (i < srcALength) && !threadStopped; i++) {
          fileInfoDicom[i] = (FileInfoDicom) (((FileInfoDicom) srcImage1.getFileInfo()[i]).clone());
          fileInfoDicom[i].setOrigin(origins);
        }

        for (i = 0; (i < srcImage2.getExtents()[2]) && !threadStopped; i++) {
          fileInfoDicom[srcALength + i] =
              (FileInfoDicom) (((FileInfoDicom) srcImage2.getFileInfo()[i]).clone());
          fileInfoDicom[srcALength + i].setOrigin(origins);
        }
      } else {
        srcBLength = srcImage2.getExtents()[2] * srcImage2.getExtents()[3];

        for (i = 0; (i < srcImage1.getExtents()[2]) && !threadStopped; i++) {
          fileInfoDicom[i] = (FileInfoDicom) (((FileInfoDicom) srcImage1.getFileInfo()[i]).clone());
          fileInfoDicom[i].setOrigin(origins);
        }

        for (i = 0; (i < srcBLength) && !threadStopped; i++) {
          fileInfoDicom[srcImage1.getExtents()[2] + i] =
              (FileInfoDicom) (((FileInfoDicom) srcImage2.getFileInfo()[i]).clone());
          fileInfoDicom[srcImage1.getExtents()[2] + i].setOrigin(origins);
        }
      }

      destImage.setFileInfo(fileInfoDicom);
    } else {
      fileInfo = destImage.getFileInfo();

      for (i = 0;
          (i < (destImage.getExtents()[2] * destImage.getExtents()[3])) && !threadStopped;
          i++) {
        fileInfo[i].setModality(srcImage1.getFileInfo()[0].getModality());
        fileInfo[i].setFileDirectory(srcImage1.getFileInfo()[0].getFileDirectory());
        fileInfo[i].setEndianess(srcImage1.getFileInfo()[0].getEndianess());
        fileInfo[i].setUnitsOfMeasure(srcImage1.getFileInfo()[0].getUnitsOfMeasure());
        fileInfo[i].setResolutions(resols);
        fileInfo[i].setExtents(destImage.getExtents());
        fileInfo[i].setMax(destImage.getMax());
        fileInfo[i].setMin(destImage.getMin());
        fileInfo[i].setImageOrientation(srcImage1.getImageOrientation());
        fileInfo[i].setPixelPadValue(srcImage1.getFileInfo()[0].getPixelPadValue());
        fileInfo[i].setPhotometric(srcImage1.getFileInfo()[0].getPhotometric());
        fileInfo[i].setAxisOrientation(srcImage1.getAxisOrientation());
      }

      if (srcImage1.getFileInfo()[0] instanceof FileInfoImageXML) {

        if (srcImage1.getNDims() > srcImage2.getNDims()) {
          srcALength = srcImage1.getExtents()[2] * srcImage1.getExtents()[3];

          for (i = 0; (i < srcALength) && !threadStopped; i++) {

            if (((FileInfoImageXML) srcImage1.getFileInfo()[i]).getPSetHashtable() != null) {
              ((FileInfoImageXML) fileInfo[i])
                  .setPSetHashtable(
                      ((FileInfoImageXML) srcImage1.getFileInfo()[i]).getPSetHashtable());
            }
          }
        } else {

          for (i = 0; (i < srcImage1.getExtents()[2]) && !threadStopped; i++) {

            if (((FileInfoImageXML) srcImage1.getFileInfo()[i]).getPSetHashtable() != null) {
              ((FileInfoImageXML) fileInfo[i])
                  .setPSetHashtable(
                      ((FileInfoImageXML) srcImage1.getFileInfo()[i]).getPSetHashtable());
            }
          }
        }
      }

      if (srcImage2.getFileInfo()[0] instanceof FileInfoImageXML) {

        if (srcImage1.getNDims() > srcImage2.getNDims()) {
          srcALength = srcImage1.getExtents()[2] * srcImage1.getExtents()[3];

          for (i = 0; (i < srcImage2.getExtents()[2]) && !threadStopped; i++) {

            if (((FileInfoImageXML) srcImage2.getFileInfo()[i]).getPSetHashtable() != null) {
              ((FileInfoImageXML) fileInfo[srcALength + i])
                  .setPSetHashtable(
                      ((FileInfoImageXML) srcImage2.getFileInfo()[i]).getPSetHashtable());
            }
          }

        } else {
          srcBLength = srcImage2.getExtents()[2] * srcImage2.getExtents()[3];

          for (i = 0; (i < srcBLength) && !threadStopped; i++) {

            if (((FileInfoImageXML) srcImage2.getFileInfo()[i]).getPSetHashtable() != null) {
              ((FileInfoImageXML) fileInfo[srcImage1.getExtents()[2] + i])
                  .setPSetHashtable(
                      ((FileInfoImageXML) srcImage2.getFileInfo()[i]).getPSetHashtable());
            }
          }
        }
      }
    }

    if (threadStopped) {
      buffer = null;
      finalize();

      return;
    }

    setCompleted(true);
    fileInfo = null;
    fileInfoDicom = null;
  }
Beispiel #8
0
  /** Starts the program. */
  public void runAlgorithm() {

    if ((srcImage1 == null) || (srcImage2 == null) || (destImage == null)) {
      displayError("Source Image(s) is null");
      setCompleted(false);

      return;
    }

    if (srcImage1.getType() != srcImage2.getType()) {
      displayError("Source Images must be of the same data type.");
      setCompleted(false);

      return;
    }

    float[] resols1 = srcImage1.getResolutions(0);
    float[] resols2 = srcImage2.getResolutions(0);

    if ((srcImage1.getNDims() == 2) && (srcImage2.getNDims() == 2)) {
      if (resols1[0] == resols2[0] && resols1[1] == resols2[1]) {
        cat2D_2D_3D();
      } else {
        displayError("Resolutions must match up");
        setCompleted(false);
        return;
      }

    } else if (((srcImage1.getNDims() == 2) && (srcImage2.getNDims() == 3))
        || ((srcImage1.getNDims() == 3) && (srcImage2.getNDims() == 2))) {
      if (resols1[0] == resols2[0] && resols1[1] == resols2[1]) {
        cat2D_3D_3D();
      } else {
        displayError("Resolutions must match up");
        setCompleted(false);
        return;
      }
    } else if ((srcImage1.getNDims() == 3)
        && (srcImage2.getNDims() == 3)
        && (destImage.getNDims() == 3)) {
      if (resols1[0] == resols2[0] && resols1[1] == resols2[1] && resols1[2] == resols2[2]) {
        cat3D_3D_3D();
      } else {
        displayError("Resolutions must match up");
        setCompleted(false);
        return;
      }
    } else if ((srcImage1.getNDims() == 3)
        && (srcImage2.getNDims() == 3)
        && (destImage.getNDims() == 4)) {
      if (resols1[0] == resols2[0] && resols1[1] == resols2[1] && resols1[2] == resols2[2]) {
        cat3D_3D_4D();
      } else {
        displayError("Resolutions must match up");
        setCompleted(false);
        return;
      }
    } else if (((srcImage1.getNDims() == 3) && (srcImage2.getNDims() == 4))
        || ((srcImage1.getNDims() == 4) && (srcImage2.getNDims() == 3))) {
      if (resols1[0] == resols2[0] && resols1[1] == resols2[1] && resols1[2] == resols2[2]) {
        cat3D_4D_4D();
      } else {
        displayError("Resolutions must match up");
        setCompleted(false);
        return;
      }

    } else if ((srcImage1.getNDims() == 4) && (srcImage2.getNDims() == 4)) {
      if (resols1[0] == resols2[0]
          && resols1[1] == resols2[1]
          && resols1[2] == resols2[2]
          && resols1[3] == resols2[3]) {
        cat4D_4D_4D();
      } else {
        displayError("Resolutions must match up");
        setCompleted(false);
        return;
      }
    } else {
      displayError("Source Image(s) dimensionality not supported.");
    }
  }