Examples with Chrono mcib3d.utils.Chrono used on opensource projects

Example 1 with Chrono

use of mcib3d.utils.Chrono in project mcib3d-core by mcib3d.

the class ImageInt method adaptiveFilter.

/**
 * Adaptive Filter in 3D (expermimental) Take 7 neighborhood, compute mean
 * and std dev Assign mean of neighborhood with lowest std dev
 *
 * @param radx
 * @param radz
 * @param rady
 * @return 3D filtered image
 */
@Deprecated
public ImageInt adaptiveFilter(float radx, float rady, float radz, int nbcpus) {
    final ImageInt adaptimg2 = (ImageInt) this.createSameDimensions();
    int nbToProcess = this.sizeZ;
    // Timer
    final Chrono time = new Chrono(nbToProcess);
    time.start();
    final AbstractLog show = new IJStatus();
    // create kernel
    final int[] ker = FastFilters3D.createKernelEllipsoid(radx, rady, radz);
    int nb = 0;
    for (int i = 0; i < ker.length; i++) {
        nb += ker[i];
    }
    final int nb2 = nb;
    final float radX2 = radx;
    final float radY2 = rady;
    final float radZ2 = radz;
    // PARALLEL (Thomas Boudier)
    final AtomicInteger ai = new AtomicInteger(0);
    Thread[] threads = ThreadUtil.createThreadArray(nbcpus);
    for (int ithread = 0; ithread < threads.length; ithread++) {
        threads[ithread] = new Thread() {

            @Override
            public void run() {
                ArrayUtil[] tab = new ArrayUtil[7];
                // displacement to take neighborhoods
                int dep = 1;
                double mes;
                double mins;
                double si;
                double me;
                for (int k = ai.getAndIncrement(); k < sizeZ; k = ai.getAndIncrement()) {
                    for (int j = 0; j < sizeY; j++) {
                        for (int i = 0; i < sizeX; i++) {
                            tab[0] = getNeighborhoodKernel(ker, nb2, i, j, k, radX2, radY2, radZ2);
                            tab[1] = getNeighborhoodKernel(ker, nb2, i + dep, j, k, radX2, radY2, radZ2);
                            tab[2] = getNeighborhoodKernel(ker, nb2, i - dep, j, k, radX2, radY2, radZ2);
                            tab[3] = getNeighborhoodKernel(ker, nb2, i, j + dep, k, radX2, radY2, radZ2);
                            tab[4] = getNeighborhoodKernel(ker, nb2, i, j - dep, k, radX2, radY2, radZ2);
                            tab[5] = getNeighborhoodKernel(ker, nb2, i, j, k + dep, radX2, radY2, radZ2);
                            tab[6] = getNeighborhoodKernel(ker, nb2, i, j, k - dep, radX2, radY2, radZ2);
                            mes = 0;
                            mins = Float.MAX_VALUE;
                            for (int c = 0; c < 7; c++) {
                                // me = tab[c].median();
                                me = tab[c].getMean();
                                si = tab[c].getStdDev();
                                if (si < mins) {
                                    mins = si;
                                    mes = me;
                                }
                            }
                            adaptimg2.setPixel(i, j, k, (int) mes);
                        }
                    }
                    if (time != null) {
                        String ti = time.getFullInfo(1);
                        if (ti != null)
                            show.log("3D adaptive : " + ti);
                    }
                }
            }
        };
    }
    ThreadUtil.startAndJoin(threads);
    return adaptimg2;
}

Example 2 with Chrono

use of mcib3d.utils.Chrono in project mcib3d-core by mcib3d.

the class TrackThreshold method process.

private ArrayList<ObjectTrack> process(ImageHandler img) {
    switch(criteria_method) {
        case CRITERIA_METHOD_MIN_ELONGATION:
            criterion = new CriterionElongation();
            bestCriterion = new BestCriteriaMin();
            break;
        case CRITERIA_METHOD_MAX_COMPACTNESS:
            criterion = new CriterionCompactness();
            bestCriterion = new BestCriteriaMax();
            break;
        case CRITERIA_METHOD_MAX_VOLUME:
            criterion = new CriterionVolume();
            bestCriterion = new BestCriteriaMax();
            break;
        case CRITERIA_METHOD_MSER:
            criterion = new CriterionVolume();
            bestCriterion = new BestCriteriaStable();
            break;
        case CRITERIA_METHOD_MAX_EDGES:
            criterion = new CriterionEdge(img, 0.5);
            bestCriterion = new BestCriteriaMax();
            break;
        case CRITERIA_METHOD_MAX_CLASSIFICATION:
            // test
            criterion = new CriterionClassification("/home/thomasb/App/ImageJ/testWEKA.arff");
            bestCriterion = new BestCriteriaMax();
            break;
        default:
            // MSER
            criterion = new CriterionVolume();
            bestCriterion = new BestCriteriaStable();
            break;
    }
    int T0, TMaximum, T1;
    int[] histogramThreshold;
    ImageLabeller labeler = new ImageLabeller(volMin, volMax);
    TMaximum = (int) img.getMax();
    if (log != null)
        log.log("Analysing histogram ...");
    histogramThreshold = initHistogram(img);
    if (histogramThreshold.length == 0)
        return null;
    T0 = histogramThreshold[0];
    // first frame
    T1 = T0;
    if (log != null)
        log.log("Computing frame for first threshold " + T1);
    ArrayList<ObjectTrack> frame1 = computeFrame(img, labeler.getObjects(img.thresholdAboveInclusive(T1)), markers, T1, criterion);
    if (log != null)
        log.log("Starting iterative thresholding ... ");
    ArrayList<ObjectTrack> allFrames = new ArrayList<ObjectTrack>();
    allFrames.addAll(frame1);
    // use histogram and unique values to loop over pixel values
    GlobalThreshold = 0;
    // 
    Chrono chrono = new Chrono(TMaximum);
    chrono.start();
    String S = null;
    if (log instanceof IJLog) {
        // was true
        ((IJLog) (log)).setUpdate(true);
    }
    // / LOOP
    while (T1 <= TMaximum) {
        int T2 = computeNextThreshold(T1, TMaximum, histogramThreshold);
        // IJ.log("" + T1 + " " + T2 + " " + TMaximum);
        if (T2 < 0)
            break;
        if (log != null) {
            S = chrono.getFullInfo(T2 - T1);
            // IJ.log("\\Update: "+S);
            if (S != null)
                log.log("task " + S);
        }
        // if (status) IJ.showStatus("Computing frame for threshold " + T2 + "                   ");
        // Threshold T2
        ImageHandler bin2 = img.thresholdAboveInclusive(T2);
        ImageHandler labels2 = labeler.getLabels(bin2);
        ArrayList<ObjectTrack> frame2 = computeFrame(img, labeler.getObjects(bin2), markers, T2, criterion);
        System.gc();
        // T2--> new T1
        T1 = T2;
        frame1 = computeAssociation(frame1, frame2, allFrames, labels2);
    }
    // thresholding
    if (log instanceof IJLog) {
        ((IJLog) (log)).setUpdate(false);
    }
    if (log != null) {
        log.log("Iterative Thresholding finished");
    }
    return allFrames;
// return computeResults(allFrames, img, bestCriterion);
}

Example 3 with Chrono

use of mcib3d.utils.Chrono in project mcib3d-core by mcib3d.

the class Align2DData method computeRotation.

/**
 *  compute the rotation for the images. the rotations will be computed between
 *  2 consecutive images
 *
 * @param  polar           true if computation in fourier space false for
 *      computation in real space
 * @param  range           the rotations computed will be between
 *      [-range,+range[
 * @param  angleprecision  the precision wanted (1 for degrees precision, 0.1
 *      for decidegrees precision)
 */
public void computeRotation(boolean polar, double range, double angleprecision) {
    ImageProcessor img1 = serie[0].getImage(true);
    img1.setRoi(selection);
    img1 = img1.crop();
    // ImageProcessor img1 = new FHTImage3D(serie[0].getImage(true)).center().getPowerSpectrum(true).getProcessor(1);
    // ImageProcessor img1 = null;
    ImageProcessor img2 = null;
    double totangles = 0;
    System.out.println("computing rotation with new method..." + polar);
    Chrono time = new Chrono(sizez - 1);
    time.start();
    for (int i = 1; i < sizez; i++) {
        img2 = serie[i].getImage(true);
        img2.setRoi(selection);
        img2 = img2.crop();
        double bestangle = 0;
        // img2 = new FHTImage3D(serie[i].getImage(true)).center().getPowerSpectrum(true).getProcessor(1);
        if (polar) {
            bestangle = computeRotation2ImagesFHT(img1, img2, range, angleprecision);
        } else {
            bestangle = computeRotation2Images(img1, img2, range, angleprecision);
        }
        totangles += bestangle;
        serie[i].addRotation(totangles);
        IJ.log("adding to " + i + " a rotation of " + totangles + " rotation to precedent image " + bestangle);
        img1 = img2;
        time.stop();
        String strtime = "rotation : " + 100 * i / (sizez - 1) + "% remaining " + time.remainString(i);
        System.out.print("\r                                                                 \r" + strtime + " total :" + time.totalTimeEstimateString(i) + "           ");
        IJ.showStatus(strtime);
    }
    totangles /= sizez - 1;
    IJ.log("adding to all a rotation of " + (-totangles));
    for (int i = 0; i < sizez; i++) {
        serie[i].addRotation(-totangles);
    }
}

Example 4 with Chrono

use of mcib3d.utils.Chrono in project mcib3d-core by mcib3d.

the class FastFilters3D method getListMaximaFloat.

public static ArrayList<Voxel3DComparable> getListMaximaFloat(ImageFloat stackorig, float vx, float vy, float vz, int nbcpus, boolean showstatus) {
    int nbToProcess = stackorig.sizeZ;
    // Timer
    final Chrono time = new Chrono(nbToProcess);
    time.start();
    final AbstractLog show = new IJStatus();
    // get stack info
    final float voisx = vx;
    final float voisy = vy;
    final float voisz = vz;
    final ImageFloat ima = stackorig;
    // PARALLEL
    final AtomicInteger ai = new AtomicInteger(0);
    final int n_cpus = nbcpus == 0 ? ThreadUtil.getNbCpus() : nbcpus;
    final int dec = (int) Math.ceil((double) ima.sizeZ / (double) n_cpus);
    Thread[] threads = ThreadUtil.createThreadArray(n_cpus);
    final ArrayList<Voxel3DComparable>[] listes = new ArrayList[n_cpus];
    for (int ithread = 0; ithread < threads.length; ithread++) {
        threads[ithread] = new Thread() {

            @Override
            public void run() {
                for (int k = ai.getAndIncrement(); k < n_cpus; k = ai.getAndIncrement()) {
                    listes[k] = ima.getListMaxima(voisx, voisy, voisz, dec * k, dec * (k + 1), time, show);
                }
            }
        };
    }
    ThreadUtil.startAndJoin(threads);
    final ArrayList<Voxel3DComparable> liste = new ArrayList<Voxel3DComparable>();
    for (ArrayList<Voxel3DComparable> li : listes) {
        liste.addAll(li);
    }
    return liste;
}

Example 5 with Chrono

use of mcib3d.utils.Chrono in project mcib3d-core by mcib3d.

the class FastFilters3D method filterFloatImage.

public static ImageFloat filterFloatImage(ImageFloat stackorig, int filter, Object3DVoxels obj, int nbcpus, boolean showstatus) {
    int nbToProcess = stackorig.sizeZ;
    if ((filter == TOPHAT) || (filter == CLOSEGRAY) || (filter == OPENGRAY))
        nbToProcess *= 2;
    // Timer
    final Chrono time = new Chrono(nbToProcess);
    time.start();
    final AbstractLog show = new IJStatus();
    final Object3DVoxels object = obj;
    // IJ.log("Using java filtering " + voisx + " " + voisy + " " + voisz + " " + filter + " " + nbcpus);
    final ImageFloat ima = stackorig;
    ImageFloat res = (ImageFloat) ima.createSameDimensions();
    if ((filter == MEAN) || (filter == MEDIAN) || (filter == MIN) || (filter == MAX) || (filter == MAXLOCAL) || (filter == TOPHAT) || (filter == VARIANCE) || (filter == CLOSEGRAY) || (filter == OPENGRAY)) {
        // PARALLEL
        final ImageFloat out = res;
        final AtomicInteger ai = new AtomicInteger(0);
        final int n_cpus = nbcpus == 0 ? ThreadUtil.getNbCpus() : nbcpus;
        int fi = filter;
        if ((fi == TOPHAT) || (fi == OPENGRAY)) {
            fi = MIN;
        }
        if (fi == CLOSEGRAY) {
            fi = MAX;
        }
        final int f = fi;
        final int dec = (int) Math.ceil((double) ima.sizeZ / (double) n_cpus);
        Thread[] threads = ThreadUtil.createThreadArray(n_cpus);
        for (int ithread = 0; ithread < threads.length; ithread++) {
            threads[ithread] = new Thread() {

                @Override
                public void run() {
                    for (int k = ai.getAndIncrement(); k < n_cpus; k = ai.getAndIncrement()) {
                        ima.filterGeneric(out, object, dec * k, dec * (k + 1), f, time, show);
                    }
                }
            };
        }
        ThreadUtil.startAndJoin(threads);
        // TOPHAT MAX
        if ((filter == TOPHAT) || (filter == OPENGRAY)) {
            final int f2 = MAX;
            final ImageFloat res2 = (ImageFloat) ima.createSameDimensions();
            ai.set(0);
            for (int ithread = 0; ithread < threads.length; ithread++) {
                threads[ithread] = new Thread() {

                    @Override
                    public void run() {
                        for (int k = ai.getAndIncrement(); k < n_cpus; k = ai.getAndIncrement()) {
                            out.filterGeneric(res2, object, dec * k, dec * (k + 1), f2, time, show);
                        }
                    }
                };
            }
            ThreadUtil.startAndJoin(threads);
            // TOPHAT DIFFERENCE
            if (filter == TOPHAT) {
                res = ima.subtractImage(res2);
            } else {
                res = res2;
            }
        }
        // CLOSING 2nd Step
        if (filter == CLOSEGRAY) {
            final int f2 = MIN;
            final ImageFloat res2 = (ImageFloat) ima.createSameDimensions();
            ai.set(0);
            for (int ithread = 0; ithread < threads.length; ithread++) {
                threads[ithread] = new Thread() {

                    @Override
                    public void run() {
                        for (int k = ai.getAndIncrement(); k < n_cpus; k = ai.getAndIncrement()) {
                            out.filterGeneric(res2, object, dec * k, dec * (k + 1), f2, time, show);
                        }
                    }
                };
            }
            ThreadUtil.startAndJoin(threads);
            res = res2;
        }
    } else if (filter == SOBEL) {
        res = ima.sobelFilter();
    } else if (filter == ADAPTIVE) {
    // res = ima.adaptiveFilter(voisx, voisy, voisz, nbcpus);
    }
    return res;
}