Exemple #1
0
  public boolean beadCalibration3d() {
    imp = IJ.getImage();
    if (imp == null) {
      IJ.noImage();
      return false;
    } else if (imp.getStackSize() == 1) {
      IJ.error("Stack required");
      return false;
    } else if (imp.getType() != ImagePlus.GRAY8 && imp.getType() != ImagePlus.GRAY16) {
      // In order to support 32bit images, pict[] must be changed to float[], and  getPixel(x, y);
      // requires a Float.intBitsToFloat() conversion
      IJ.error("8 or 16 bit greyscale image required");
      return false;
    }
    width = imp.getWidth();
    height = imp.getHeight();
    nslices = imp.getStackSize();
    imtitle = imp.getTitle();

    models[0] = "*None*";
    models[1] = "line";
    models[2] = "2nd degree polynomial";
    models[3] = "3rd degree polynomial";
    models[4] = "4th degree polynomial";

    GenericDialog gd = new GenericDialog("3D PALM calibration");
    gd.addNumericField("Maximum FWHM (in px)", prefs.get("QuickPALM.3Dcal_fwhm", 20), 0);
    gd.addNumericField(
        "Particle local threshold (% maximum intensity)", prefs.get("QuickPALM.pthrsh", 20), 0);
    gd.addNumericField("Z-spacing (nm)", prefs.get("QuickPALM.z-step", 10), 2);
    gd.addNumericField("Calibration Z-smoothing (radius)", prefs.get("QuickPALM.window", 1), 0);
    gd.addChoice("Model", models, prefs.get("QuickPALM.model", models[3]));
    gd.addCheckbox(
        "Show divergence of bead positions against model",
        prefs.get("QuickPALM.3Dcal_showDivergence", false));
    gd.addCheckbox("Show extra particle info", prefs.get("QuickPALM.3Dcal_showExtraInfo", false));
    gd.addMessage("\n\nDon't forget to save the table in the end...");
    gd.showDialog();
    if (gd.wasCanceled()) return false;
    fwhm = gd.getNextNumber();
    prefs.set("QuickPALM.QuickPALM.3Dcal_fwhm", fwhm);
    pthrsh = gd.getNextNumber() / 100;
    prefs.set("QuickPALM.pthrsh", pthrsh * 100);
    cal_z = gd.getNextNumber();
    prefs.set("QuickPALM.z-step", cal_z);
    window = (int) gd.getNextNumber();
    prefs.set("QuickPALM.window", window);
    model = gd.getNextChoice();
    prefs.set("QuickPALM.model", model);
    part_divergence = gd.getNextBoolean();
    prefs.set("QuickPALM.3Dcal_showDivergence", part_divergence);
    part_extrainfo = gd.getNextBoolean();
    prefs.set("QuickPALM.3Dcal_showExtraInfo", part_extrainfo);
    return true;
  }
Exemple #2
0
 /** Quit using a separate thread, hopefully avoiding thread deadlocks. */
 public void run() {
   quitting = true;
   boolean changes = false;
   int[] wList = WindowManager.getIDList();
   if (wList != null) {
     for (int i = 0; i < wList.length; i++) {
       ImagePlus imp = WindowManager.getImage(wList[i]);
       if (imp != null && imp.changes == true) {
         changes = true;
         break;
       }
     }
   }
   Frame[] frames = WindowManager.getNonImageWindows();
   if (frames != null) {
     for (int i = 0; i < frames.length; i++) {
       if (frames[i] != null && (frames[i] instanceof Editor)) {
         if (((Editor) frames[i]).fileChanged()) {
           changes = true;
           break;
         }
       }
     }
   }
   if (windowClosed
       && !changes
       && Menus.window.getItemCount() > Menus.WINDOW_MENU_ITEMS
       && !(IJ.macroRunning() && WindowManager.getImageCount() == 0)) {
     GenericDialog gd = new GenericDialog("ImageJ", this);
     gd.addMessage("Are you sure you want to quit ImageJ?");
     gd.showDialog();
     quitting = !gd.wasCanceled();
     windowClosed = false;
   }
   if (!quitting) return;
   if (!WindowManager.closeAllWindows()) {
     quitting = false;
     return;
   }
   // IJ.log("savePreferences");
   if (applet == null) {
     saveWindowLocations();
     Prefs.savePreferences();
   }
   IJ.cleanup();
   // setVisible(false);
   // IJ.log("dispose");
   dispose();
   if (exitWhenQuitting) System.exit(0);
 }
 void addSelection() {
   ImagePlus imp = IJ.getImage();
   String macroOptions = Macro.getOptions();
   if (macroOptions != null && IJ.macroRunning() && macroOptions.indexOf("remove") != -1) {
     imp.setOverlay(null);
     return;
   }
   Roi roi = imp.getRoi();
   if (roi == null && imp.getOverlay() != null) {
     GenericDialog gd = new GenericDialog("No Selection");
     gd.addMessage("\"Overlay>Add\" requires a selection.");
     gd.setInsets(15, 40, 0);
     gd.addCheckbox("Remove existing overlay", false);
     gd.showDialog();
     if (gd.wasCanceled()) return;
     if (gd.getNextBoolean()) imp.setOverlay(null);
     return;
   }
   if (roi == null) {
     IJ.error("This command requires a selection.");
     return;
   }
   roi = (Roi) roi.clone();
   if (roi.getStrokeColor() == null) roi.setStrokeColor(Toolbar.getForegroundColor());
   int width = Line.getWidth();
   Rectangle bounds = roi.getBounds();
   boolean tooWide = width > Math.max(bounds.width, bounds.height) / 3.0;
   if (roi.getStroke() == null && width > 1 && !tooWide) roi.setStrokeWidth(Line.getWidth());
   Overlay overlay = imp.getOverlay();
   if (overlay != null && overlay.size() > 0 && !roi.isDrawingTool()) {
     Roi roi2 = overlay.get(overlay.size() - 1);
     if (roi.getStroke() == null) roi.setStrokeWidth(roi2.getStrokeWidth());
     if (roi.getFillColor() == null) roi.setFillColor(roi2.getFillColor());
   }
   boolean points = roi instanceof PointRoi && ((PolygonRoi) roi).getNCoordinates() > 1;
   if (points) roi.setStrokeColor(Color.red);
   if (!IJ.altKeyDown() && !(roi instanceof Arrow)) {
     RoiProperties rp = new RoiProperties("Add to Overlay", roi);
     if (!rp.showDialog()) return;
   }
   String name = roi.getName();
   boolean newOverlay = name != null && name.equals("new-overlay");
   if (overlay == null || newOverlay) overlay = new Overlay();
   overlay.add(roi);
   imp.setOverlay(overlay);
   overlay2 = overlay;
   if (points || (roi instanceof ImageRoi) || (roi instanceof Arrow)) imp.killRoi();
   Undo.setup(Undo.OVERLAY_ADDITION, imp);
 }
Exemple #4
0
 // DICOM options
 void dicom() {
   GenericDialog gd = new GenericDialog("DICOM Options");
   gd.addCheckbox("Open as 32-bit float", Prefs.openDicomsAsFloat);
   // gd.addCheckbox("Calculate voxel depth", Prefs.calculateDicomVoxelDepth);
   gd.addMessage("Orthogonal Views");
   gd.setInsets(5, 40, 0);
   gd.addCheckbox("Rotate YZ", Prefs.rotateYZ);
   gd.setInsets(0, 40, 0);
   gd.addCheckbox("Flip XZ", Prefs.flipXZ);
   gd.showDialog();
   if (gd.wasCanceled()) return;
   Prefs.openDicomsAsFloat = gd.getNextBoolean();
   // Prefs.calculateDicomVoxelDepth = gd.getNextBoolean();
   Prefs.rotateYZ = gd.getNextBoolean();
   Prefs.flipXZ = gd.getNextBoolean();
 }
Exemple #5
0
  // Input/Output options
  void io() {
    GenericDialog gd = new GenericDialog("I/O Options");
    gd.addNumericField("JPEG quality (0-100):", FileSaver.getJpegQuality(), 0, 3, "");
    gd.addNumericField("GIF and PNG transparent index:", Prefs.getTransparentIndex(), 0, 3, "");
    gd.addStringField(
        "File extension for tables (.txt, .xls or .csv):", Prefs.get("options.ext", ".csv"), 4);
    gd.addCheckbox("Use JFileChooser to open/save", Prefs.useJFileChooser);
    if (!IJ.isMacOSX())
      gd.addCheckbox("Use_file chooser to import sequences", Prefs.useFileChooser);
    gd.addCheckbox("Save TIFF and raw in Intel byte order", Prefs.intelByteOrder);
    gd.addCheckbox("Skip dialog when opening .raw files", Prefs.skipRawDialog);

    gd.setInsets(15, 20, 0);
    gd.addMessage("Results Table Options");
    gd.setInsets(3, 40, 0);
    gd.addCheckbox("Copy_column headers", Prefs.copyColumnHeaders);
    gd.setInsets(0, 40, 0);
    gd.addCheckbox("Copy_row numbers", !Prefs.noRowNumbers);
    gd.setInsets(0, 40, 0);
    gd.addCheckbox("Save_column headers", !Prefs.dontSaveHeaders);
    gd.setInsets(0, 40, 0);
    gd.addCheckbox("Save_row numbers", !Prefs.dontSaveRowNumbers);

    gd.showDialog();
    if (gd.wasCanceled()) return;
    int quality = (int) gd.getNextNumber();
    if (quality < 0) quality = 0;
    if (quality > 100) quality = 100;
    FileSaver.setJpegQuality(quality);
    int transparentIndex = (int) gd.getNextNumber();
    Prefs.setTransparentIndex(transparentIndex);
    String extension = gd.getNextString();
    if (!extension.startsWith(".")) extension = "." + extension;
    Prefs.set("options.ext", extension);
    Prefs.useJFileChooser = gd.getNextBoolean();
    if (!IJ.isMacOSX()) Prefs.useFileChooser = gd.getNextBoolean();
    Prefs.intelByteOrder = gd.getNextBoolean();
    Prefs.skipRawDialog = gd.getNextBoolean();
    Prefs.copyColumnHeaders = gd.getNextBoolean();
    Prefs.noRowNumbers = !gd.getNextBoolean();
    Prefs.dontSaveHeaders = !gd.getNextBoolean();
    Prefs.dontSaveRowNumbers = !gd.getNextBoolean();
    return;
  }
Exemple #6
0
 void checkForCalibrationConflict(ImagePlus imp, Calibration cal) {
   Calibration gcal = imp.getGlobalCalibration();
   if (gcal == null || !showConflictMessage || IJ.isMacro()) return;
   if (cal.pixelWidth == gcal.pixelWidth && cal.getUnit().equals(gcal.getUnit())) return;
   GenericDialog gd = new GenericDialog(imp.getTitle());
   gd.addMessage("The calibration of this image conflicts\nwith the current global calibration.");
   gd.addCheckbox("Disable_Global Calibration", true);
   gd.addCheckbox("Disable_these Messages", false);
   gd.showDialog();
   if (gd.wasCanceled()) return;
   boolean disable = gd.getNextBoolean();
   if (disable) {
     imp.setGlobalCalibration(null);
     imp.setCalibration(cal);
     WindowManager.repaintImageWindows();
   }
   boolean dontShow = gd.getNextBoolean();
   if (dontShow) showConflictMessage = false;
 }
Exemple #7
0
  public boolean analyseParticles(MyFunctions f) {
    GenericDialog gd = new GenericDialog("Analyse PALM/STORM Particles");
    gd.addNumericField("Minimum SNR", prefs.get("QuickPALM.snr", 5), 2);
    gd.addNumericField("Maximum FWHM (in px)", prefs.get("QuickPALM.fwhm", 4), 0);
    gd.addNumericField("Image plane pixel size (nm)", prefs.get("QuickPALM.pixelsize", 106), 2);
    gd.addCheckbox("Smart SNR", prefs.get("QuickPALM.smartsnr", true));
    gd.addCheckbox(
        "3D PALM (astigmatism) - will require calibration file",
        prefs.get("QuickPALM.is3d", false));
    gd.addCheckbox("Online rendering", prefs.get("QuickPALM.view", true));
    gd.addCheckbox("Attach to running acquisition", prefs.get("QuickPALM.attach", false));
    gd.addCheckbox("Stream particle info directly into file", prefs.get("QuickPALM.stream", true));
    gd.addMessage("\n");
    // -----------------------------------------
    gd.addMessage("-- Online rendering settings (used only if selected) --");
    gd.addMessage("\n");
    gd.addNumericField("Pixel size of rendered image (nm)", 30, 2);
    gd.addNumericField("Accumulate last (0 to accumulate all frames)", 0, 0);
    gd.addNumericField("Update every (frames)", 10, 0);
    // gd.addNumericField("Allow color saturation (%)", 50, 0);
    gd.addMessage("\n");
    // -----------------------------------------
    gd.addMessage("-- Attach to running acquisition settings (used only if selected) --");
    gd.addMessage("\n");
    gd.addStringField(
        "_Image name pattern (NN...NN represents the numerical change)",
        prefs.get("QuickPALM.pattern", "imgNNNNNNNNN.tif"),
        20);
    gd.addNumericField("Start NN...NN with", 0, 0);
    gd.addNumericField("In acquisition max. wait time for new image (ms)", 50, 0);
    gd.addMessage("\n");
    // -----------------------------------------
    gd.addMessage("-- Advanced settings (don't normally need to be changed) --");
    gd.addMessage("\n");
    gd.addNumericField("_Minimum symmetry (%)", prefs.get("QuickPALM.symmetry", 50), 0);
    gd.addNumericField(
        "Local threshold (% maximum intensity)", prefs.get("QuickPALM.lthreshold", 20), 0);
    gd.addNumericField("_Maximum iterations per frame", prefs.get("QuickPALM.maxiter", 1000), 0);
    gd.addNumericField(
        "Threads (each takes ~3*[frame size] in memory)", prefs.get("QuickPALM.nthreads", 50), 0);
    gd.addMessage("\n\nDon't forget to save the table in the end...");

    gd.showDialog();
    if (gd.wasCanceled()) return false;

    snr = (int) gd.getNextNumber();
    prefs.set("QuickPALM.snr", snr);
    fwhm = gd.getNextNumber();
    prefs.set("QuickPALM.fwhm", fwhm);
    pixelsize = gd.getNextNumber();
    prefs.set("QuickPALM.pixelsize", pixelsize);

    smartsnr = gd.getNextBoolean();
    prefs.set("QuickPALM.smartsnr", smartsnr);
    is3d = gd.getNextBoolean();
    prefs.set("QuickPALM.is3d", is3d);
    view = gd.getNextBoolean();
    prefs.set("QuickPALM.view", view);
    attach = gd.getNextBoolean();
    prefs.set("QuickPALM.attach", attach);

    if (gd.getNextBoolean()) {
      f.psave = new ParticleSaver();
      f.psave.setup();
      prefs.set("QuickPALM.stream", true);
    } else prefs.set("QuickPALM.stream", false);
    // --

    magn = pixelsize / gd.getNextNumber();
    viewer_accumulate = (int) gd.getNextNumber();
    viewer_update = (int) gd.getNextNumber();

    // --
    pattern = gd.getNextString().trim();
    prefs.set("QuickPALM.pattern", pattern);
    prefix = pattern.substring(0, pattern.indexOf("N"));
    sufix = pattern.substring(pattern.lastIndexOf("N") + 1, pattern.length());
    nimchars = pattern.split("N").length - 1;
    nimstart = (int) gd.getNextNumber();
    waittime = (int) gd.getNextNumber();

    // --

    symmetry = gd.getNextNumber() / 100;
    prefs.set("QuickPALM.symmetry", symmetry);
    pthrsh = gd.getNextNumber() / 100;
    prefs.set("QuickPALM.lthreshold", pthrsh * 100);
    maxpart = (int) gd.getNextNumber();
    prefs.set("QuickPALM.maxiter", maxpart);
    threads = (int) gd.getNextNumber();
    prefs.set("QuickPALM.nthreads", threads);

    return true;
  }
Exemple #8
0
  public boolean reconstructDataset() {

    view_modes[0] = "3D color";
    view_modes[1] = "2D histogram";
    view_modes[2] = "2D particle intensity (16-bit)";
    view_modes[3] = "2D particle intensity (8-bit)";

    GenericDialog gd = new GenericDialog("Reconstruct PALM/STORM Dataset");
    gd.addNumericField(
        "Target pixel size for the rendered image (nm)",
        prefs.get("QuickPALM.viewer_tpixelsize", 30),
        2);
    gd.addNumericField("Original image width (px)", prefs.get("QuickPALM.viewer_owidth", 512), 2);
    gd.addNumericField("Original image height (px)", prefs.get("QuickPALM.viewer_oheight", 512), 2);
    gd.addChoice("View mode", view_modes, prefs.get("QuickPALM.view_mode", view_modes[1]));
    // gd.addNumericField("Allow image saturation (%)", prefs.get("QuickPALM.saturation", 50), 0);

    gd.addCheckbox(
        "Simulate sub-difraction spot (gaussian convolution - only 2D)",
        prefs.get("QuickPALM.viewer_doConvolve", true));
    // gd.addCheckbox("Make 3D stack", prefs.get("QuickPALM.viewer_do3d", false));
    // gd.addCheckbox("Make movie", prefs.get("QuickPALM.viewer_doMovie", false));
    gd.addCheckbox("Make 3D stack", false);
    gd.addCheckbox("Make movie", false);
    // gd.addCheckbox("Save only and don't show", prefs.get("QuickPALM.viewer_doSave", false));
    gd.addMessage("\n");

    // -----------------------------------------
    gd.addMessage("-- Simulate sub-difraction spot settings (used only if selected) --");
    gd.addNumericField("FWHM of the spot", prefs.get("QuickPALM.viewer_fwhm", 30), 2);
    gd.addMessage("\n");

    // -----------------------------------------
    gd.addMessage("-- Make 3D stack settings (used only if selected) --");
    gd.addNumericField("Z-spacing between slices (nm)", prefs.get("QuickPALM.viewer_zstep", 50), 2);
    gd.addNumericField(
        "Merge particle Z-position above (nm - 0 for full Z range)",
        prefs.get("QuickPALM.viewer_mergeabove", 0),
        2);
    gd.addNumericField(
        "Merge particle Z-position bellow (nm - 0 for full Z range)",
        prefs.get("QuickPALM.viewer_mergebellow", 0),
        2);
    gd.addMessage("\n");

    // -----------------------------------------
    gd.addMessage("-- Make movie settings (used only if selected) --");
    gd.addNumericField(
        "Make a reconstruction in every N frames", prefs.get("QuickPALM.viewer_update", 10), 0);
    gd.addNumericField(
        "Accumulate N neighboring frames for each reconstruction\n(set to 0 to accumulate all the preceding frames)",
        prefs.get("QuickPALM.viewer_accumulate", 100),
        0);

    gd.showDialog();
    if (gd.wasCanceled()) return false;

    viewer_tpixelsize = gd.getNextNumber();
    prefs.set("QuickPALM.viewer_tpixelsize", viewer_tpixelsize);
    viewer_owidth = (int) gd.getNextNumber();
    prefs.set("QuickPALM.viewer_owidth", viewer_owidth);
    viewer_oheight = (int) gd.getNextNumber();
    prefs.set("QuickPALM.viewer_oheight", viewer_oheight);
    view_mode = gd.getNextChoice();
    prefs.set("QuickPALM.view_mode", view_mode);

    viewer_doConvolve = gd.getNextBoolean();
    prefs.set("QuickPALM.viewer_doConvolve", viewer_doConvolve);
    viewer_do3d = gd.getNextBoolean();
    prefs.set("QuickPALM.viewer_do3d", viewer_do3d);
    viewer_doMovie = gd.getNextBoolean();
    prefs.set("QuickPALM.viewer_doMovie", viewer_doMovie);
    // viewer_doSave = gd.getNextBoolean();
    // prefs.set("QuickPALM.viewer_doSave", viewer_doSave);

    // -- Simulate sub-difraction spot
    viewer_fwhm = gd.getNextNumber();
    prefs.set("QuickPALM.viewer_fwhm", viewer_fwhm);

    // -- Show B&W
    // viewer_is8bit = gd.getNextBoolean();
    // prefs.set("QuickPALM.viewer_is8bit", viewer_is8bit);

    // -- Make 3D stack
    viewer_zstep = gd.getNextNumber();
    prefs.set("QuickPALM.viewer_zstep", viewer_zstep);
    viewer_mergeabove = gd.getNextNumber();
    prefs.set("QuickPALM.viewer_mergeabove", viewer_mergeabove);
    viewer_mergebellow = gd.getNextNumber();
    prefs.set("QuickPALM.viewer_mergebellow", viewer_mergebellow);

    // -- Make Movie
    viewer_update = (int) gd.getNextNumber();
    prefs.set("QuickPALM.viewer_update", viewer_update);
    viewer_accumulate = (int) gd.getNextNumber();
    prefs.set("QuickPALM.viewer_accumulate", viewer_accumulate);

    return true;
  }
Exemple #9
0
 public void itemStateChanged(ItemEvent e) {
   ImagePlus imp = WindowManager.getCurrentImage();
   if (imp == null) return;
   if (!imp.isComposite()) {
     int channels = imp.getNChannels();
     if (channels == 1 && imp.getStackSize() <= 4) channels = imp.getStackSize();
     if (imp.getBitDepth() == 24 || (channels > 1 && channels < CompositeImage.MAX_CHANNELS)) {
       GenericDialog gd = new GenericDialog(imp.getTitle());
       gd.addMessage("Convert to multi-channel composite image?");
       gd.showDialog();
       if (gd.wasCanceled()) return;
       else IJ.doCommand("Make Composite");
     } else {
       IJ.error(
           "Channels",
           "A composite image is required (e.g., "
               + moreLabel
               + " Open HeLa Cells),\nor create one using "
               + moreLabel
               + " Make Composite.");
       return;
     }
   }
   if (!imp.isComposite()) return;
   CompositeImage ci = (CompositeImage) imp;
   Object source = e.getSource();
   if (source == choice) {
     int index = ((Choice) source).getSelectedIndex();
     switch (index) {
       case 0:
         ci.setMode(IJ.COMPOSITE);
         break;
       case 1:
         ci.setMode(IJ.COLOR);
         break;
       case 2:
         ci.setMode(IJ.GRAYSCALE);
         break;
     }
     ci.updateAndDraw();
     if (Recorder.record) {
       String mode = null;
       switch (index) {
         case 0:
           mode = "composite";
           break;
         case 1:
           mode = "color";
           break;
         case 2:
           mode = "grayscale";
           break;
       }
       Recorder.record("Stack.setDisplayMode", mode);
     }
   } else if (source instanceof Checkbox) {
     for (int i = 0; i < checkbox.length; i++) {
       Checkbox cb = (Checkbox) source;
       if (cb == checkbox[i]) {
         if (ci.getMode() == IJ.COMPOSITE) {
           boolean[] active = ci.getActiveChannels();
           active[i] = cb.getState();
           if (Recorder.record) {
             String str = "";
             for (int c = 0; c < ci.getNChannels(); c++) str += active[c] ? "1" : "0";
             Recorder.record("Stack.setActiveChannels", str);
             Recorder.record("//Stack.toggleChannel", imp.getChannel());
           }
         } else {
           imp.setPosition(i + 1, imp.getSlice(), imp.getFrame());
           if (Recorder.record) Recorder.record("Stack.setChannel", i + 1);
         }
         ci.updateAndDraw();
         return;
       }
     }
   }
 }
  /* Setup GUI */
  protected final boolean setup() {
    if (IJ.versionLessThan("1.40c")) {
      return false;
    } else {
      int[] ids = WindowManager.getIDList();
      if (ids != null && ids.length >= 2) {
        ArrayList titlesList = new ArrayList();
        ArrayList idsList = new ArrayList();
        String currentTitle = null;

        for (int titles = 0; titles < ids.length; ++titles) {
          ImagePlus var1 = WindowManager.getImage(ids[titles]);
          titlesList.add(var1.getTitle());
          idsList.add(Integer.valueOf(ids[titles]));
          if (var1 == WindowManager.getCurrentImage()) {
            currentTitle = var1.getTitle();
          }
        }

        if (titlesList.size() < 2) {
          IJ.showMessage("You should have at least two stacks - stimulus and response.");
          return false;
        } else {
          String[] var8 = new String[titlesList.size()];
          titlesList.toArray(var8);
          if (currentTitle == null) {
            currentTitle = var8[0];
          }
          SubstackMaker sm = new SubstackMaker();
          GenericDialog gd = new GenericDialog("AAP - 1.1.0");
          // gd.setInsets(10, 45, 0);
          gd.addChoice("Stimulus stack", var8, currentTitle);
          gd.addChoice("Response stack", var8, currentTitle.equals(var8[0]) ? var8[1] : var8[0]);
          String defautltSlices =
              "1-" + WindowManager.getImage(((Integer) idsList.get(0)).intValue()).getStackSize();
          gd.addMessage("Enter a range (e.g. 2-14)...", null, Color.darkGray);
          gd.addStringField("Slices of Response:", defautltSlices, 40);
          gd.addCheckbox("Remove first slice", true);
          gd.addCheckbox("Use Artifact from response", true);
          gd.showDialog();
          if (gd.wasCanceled()) {
            return false;
          } else {
            this.imp_s =
                WindowManager.getImage(((Integer) idsList.get(gd.getNextChoiceIndex())).intValue());
            this.imp_r =
                WindowManager.getImage(((Integer) idsList.get(gd.getNextChoiceIndex())).intValue());
            String userInput = gd.getNextString();
            this.dt_r = Activity_Analysis.findSignalDt(this.imp_r.getTitle());
            if (userInput == null) {
              return false;
            }
            IJ.showStatus(" Making substack copy of selection...");
            this.imp_r = sm.makeSubstack(this.imp_r, userInput);
            this.imp_s_index = getFirstNLast(this.imp_r, userInput);
            if (this.imp_s_index[0] != 1 | !gd.getNextBoolean()) this.removeFirst = false;
            if (gd.getNextBoolean()) this.useArtifact = true;
            // this.imp_s = makeStimSubstack(this.imp_s , userInput);
            return true;
          }
        }
      } else {
        IJ.showMessage("You should have at least two stacks open.");
        return false;
      }
    }
  }