Question

所以我正在为我的工作做一个小项目，我需要拍摄两个图像，一个核和一个高尔基体，并用箭头将它们连接起来，两个质心作为端点。我现在已经把自己的大脑搞砸了一段时间，这里是java插件的来源。它显然有一些错误，我是java和imagej的新手，所以请耐心等待...提前感谢...

所以我的想法是，一旦将测量结果读入一个大阵列，我就会继续找到每个高尔基体最接近的相应核，然后将它们连接起来。为此，我设置了一个数组并找到了该数组中的最小距离，然后继续使用我在其他人的插件中找到的方法绘制它。

我应该说结果窗口显示了一堆图像的两个独立列中的x坐标和y坐标，其中一个是大约1000个蓝色核，还有500个红色高尔基体，最后一列是堆栈。

我不太清楚问题是什么......我不明白如何将图像绘制到图像处理器......我一直在阅读一些教程，但我发现它们相对令人困惑。 ..

import ij.*;
import ij.process.*;
import ij.gui.*; 
import java.awt.*;
import java.util.Arrays;
import java.util.Collections;
import ij.plugin.*;
import ij.plugin.filter.*;
import ij.measure.*;

public class CentroidFinder_ implements PlugInFilter {
     protected ImageStack cellstack;
     ImagePlus[] cellImages = cellstack.getImageArray();
     ImagePlus arrowImage = arrowImage.createImage("ArrayFile", 1600,1200,1);

     ResultsTable rt = Analyzer.getResultsTable();
     public int setup(String arg, ImagePlus imp) {
    cellstack = imp.getStack();

    this.imp = imp;
    return STACK_REQUIRED;
 }

public void run(ImageProcessor ip) 
{
    int[] blueCentroidsX = {};
    int[] blueCentroidsY = {};
    int[] redCentroidsX = {};
    int[] redCentroidsY = {};
    int xColumnIndex = rt.getColumnHeading("X");
    int yColumnIndex = rt.getColumnHeading("Y");
    int sliceNumberIndex = rt.getColumnHeading("Slice");


    float[] sliceCategoryPerRow = (rt.getColumn(sliceNumberIndex));

    for (int counter = 0; counter < sliceCategoryPerRow.Length; counter++)
    {
        if (sliceCategoryPerRow[counter] == 1)
        {
            blueCentroidsX[counter] = (int)(rt.getValueAsDouble(xColumnIndex, counter)); //This might be a source of error
            blueCentroidsY[counter] = (int)(rt.getValue(yColumnIndex, counter));
        }
        if (sliceCategoryPerRow[counter] == 2)
        {
            redCentroidsX[counter] = (int)rt.getValue(xColumnIndex, counter); //This might be a source of error
            redCentroidsY[counter] = (int)rt.getValue(yColumnIndex, counter);
        }
    }
    if ((blueCentroidsX.length + redCentroidsX.length) =! sliceCategoryPerRow.length)
    {
        error ("Error Message", "Something is wrong with the columns");
    }

    boolean blueIsBigger = true;

    if (blueCentroidsX.length < redCentroids.length)
        blueIsBigger = false;

    int[][] startingArrow = {};
    int[][] endingArrow = {};
    int[][] tempDistance = {};
    int counterTag;
    float[] distanceList = {};
    for (int j = 0; j < redCentroidsX.length; j++)
    {
        for (int k = 0; k < blueCentroidsX.length; k++)
        {
            tempDistance = distance (redCentroidsX[j], redCentroidsY[j], 
                                   blueCentroidsX[k], blueCentroidsY[k]);
            if (throwAwayDistance (tempDistance))
                continue;
            distanceList = distanceList.addAll({tempDistance, k});
        }
        if (distanceList.length == 0)
        {
            break;
        }
        counterTag = 0; 
        for (int l = 1; l < distanceList.length; l++)
        {
            if ((distanceList[l][0] < distanceList[l-1][0]))
                counterTag = distanceList[l][1];
        }
        startingArrow = startingArrow.addAll(({(int)blueCentroidsX[counterTag],
                                         (int)blueCentroidsY[counterTag])});
        endingArrow = add(endingArrow, {(int)redCentroidsX[j], int()redCentroidsY[j]});
    }
    if ((startingArrow.length != endingArrow.length)
        error ("Error Message", "Something has caused there not to be equal coordinates");

    for (int m = 0; m < startingArrow.length; m++)
    {
        for (int n = 0; n <endingArrow.length; n++)
        {
            drawArrow (imp, startingArrow[m][0], startingArrow[m][0],
                        endingArrow[n][0], endingArrow[n][1], 1)
        }
    }



stack.addSlice(arrowImage);

public void drawArrow(ImageProcessor ip, int x1, int y1, int x2, int y2, double size) 
{
    double dx = x2-x1;
    double dy = y2-y1;
    double ra = java.lang.Math.sqrt(dx*dx + dy*dy);
    dx /= ra;
    dy /= ra;
    int x3 = (int)Math.round(x2-dx*size);
    int y3 = (int)Math.round(y2-dy*size);
    double r = 0.3*size;
    int x4 = (int)Math.round(x3+dy*r);
    int y4 = (int)Math.round(y3-dx*r);
    int x5 = (int)Math.round(x3-dy*r);
    int y5 = (int)Math.round(y3+dx*r);
    ip.moveTo(x1, y1); ip.lineTo(x2, y2);
    ip.moveTo(x4,y4); ip.lineTo(x2,y2); ip.lineTo(x5,y5);
}
//Mathematical Functions:

public boolean throwAwayDistance (float distance)
{
    if (distance >= 25.0)
        return true;
    else return false;
}

public float distance (x1,y1,x2,y2)
{
    int length;
    return length = (((x1-x2)^2 + (y1-y2)^2)^(.5));
}

}

Thank you all for all your help!

Answer 1

由于您的代码无法编译，因此如果不投入某些调试，很难看出您的问题在哪里。

让我补充一些建议：

既然你说你是ImageJ和Java的新手，你应该阅读斐济维基上的this introduction（斐济是ImageJ的发行版，包括许多针对生命科学的有用插件）以及艾伯特卡多纳的伟大tutorial。
您正在使用旨在处理单张图片的PlugInFilter，即ImageProcessor。也许使用PlugIn会更合适，因为你使用的是多个输入图像（或通道），而你的输出还在另一个图像中（虽然它可能在同一个堆栈中）
您的drawArrow方法使用低级方式来操作输出图像（就像您将ImagePlus移交到期望ImageProcessor的方式一样不管用）。一种更简单的方法是在记录命令时首先在GUI中执行预期的过程，然后在插件中使用这些高级命令：
- 在斐济/ ImageJ内，点击Plugins > Macros > Record...，然后在“记录：”下拉菜单中选择Plugin。
- 选择Arrow工具（右键单击行选择工具），双击更改设置，在打开的图像上绘制箭头，最后将其添加到{{ 1}}通过Overlay。
- 按照以下步骤操作，您最终会在Recorder窗口中找到以下代码，这些代码可以在插件中轻松使用，而无需处理任何像素阵列：

        IJ.run("Arrow Tool...", "width=2 size=10 color=black style=Filled");
        imp.setRoi(new Line(92, 184, 189, 131));
        IJ.run("Add Selection...", "");

您应该能够在原始图像顶部的叠加层中显示箭头。

希望有所帮助。

ImageJ - 使用插件链接两个图像的质心的绘制箭头

1 个答案: