public void integrateStackStart(IntegrateExp integrator) { curBgInside.clear(); curBgOutside.clear(); // curBgInt = 0; // curBgVol = 0; // Zero out arrays sliceExp = new double[numSubDiv]; sliceVol = new int[numSubDiv]; }
/** * Fills all keys contained in the receiver into the specified list. Fills the list, starting at * index 0. After this call returns the specified list has a new size that equals * <tt>this.size()</tt>. Iteration order is guaranteed to be <i>identical</i> to the order used by * method {@link #forEachKey(IntProcedure)}. * * <p>This method can be used to iterate over the keys of the receiver. * * @param list the list to be filled, can have any size. */ public void keys(IntArrayList list) { list.setSize(distinct); int[] elements = list.elements(); int[] tab = table; byte[] stat = state; int j = 0; for (int i = tab.length; i-- > 0; ) { if (stat[i] == FULL) elements[j++] = tab[i]; } }
/** * Fills all pairs satisfying a given condition into the specified lists. Fills into the lists, * starting at index 0. After this call returns the specified lists both have a new size, the * number of pairs satisfying the condition. Iteration order is guaranteed to be <i>identical</i> * to the order used by method {@link #forEachKey(IntProcedure)}. * * <p><b>Example:</b> <br> * * <pre> * IntDoubleProcedure condition = new IntDoubleProcedure() { // match even keys only * public boolean apply(int key, double value) { return key%2==0; } * } * keys = (8,7,6), values = (1,2,2) --> keyList = (6,8), valueList = (2,1)</tt> * </pre> * * @param condition the condition to be matched. Takes the current key as first and the current * value as second argument. * @param keyList the list to be filled with keys, can have any size. * @param valueList the list to be filled with values, can have any size. */ public void pairsMatching( final IntDoubleProcedure condition, final IntArrayList keyList, final DoubleArrayList valueList) { keyList.clear(); valueList.clear(); for (int i = table.length; i-- > 0; ) { if (state[i] == FULL && condition.apply(table[i], values[i])) { keyList.add(table[i]); valueList.add(values[i]); } } }
/** Stable median calculation. */ public double calcStableMedian(double lowerFrac, double upperFrac, IntArrayList list) { // This works for any size! list.trimToSize(); Arrays.sort(list.elements()); int sum = 0; int cnt = 0; for (int i = (int) (lowerFrac * list.size()); i < (int) (list.size() * upperFrac); i++) { sum += list.get(i); cnt++; } return (double) sum / cnt; // below is the original. it Relies on bucket-sorting. It should be perfectly possible to write // a linear-time stable median // based on the normal linear-time median algorithm. This is needed to handle non-8bit images. // Value might be off a bit but not much (need to think of indexing), and it doesn't matter for // this application /* int numbins=66000; int[] elem=list.elements(); int numElem=list.size(); //Calculate histogram int[] histogram=new int[numbins]; //int[] elem=curBgOutside.elements(); //int numElem=curBgOutside.size(); for(int i=0;i<numElem;i++) histogram[elem[i]]++; int jumpElem=0; int lowerIndex=(int)(numElem*lowerFrac); int upperIndex=(int)(numElem*upperFrac); int sum=0; int cnt=0; for(int i=0;i<numbins;i++) { int thisNum=histogram[i]; int take=Math.min(upperIndex,jumpElem+thisNum)-Math.max(lowerIndex, jumpElem); if(take>0) { sum+=take*i; cnt+=take; } jumpElem+=thisNum; } return (double)sum/cnt; */ }
public void integrateImage(IntegrateExp integrator) { integrator.ensureImageLoaded(); // Calculate distance mask lazily. Assumes shell does not move over time. double[] lenMapArr; if (distanceMap.containsKey(integrator.curZint)) { EvPixels lenMap = distanceMap.get(integrator.curZint); lenMapArr = lenMap.getArrayDouble(); } else { EvPixels lenMap = new EvPixels( EvPixelsType.DOUBLE, integrator.pixels.getWidth(), integrator.pixels.getHeight()); lenMapArr = lenMap.getArrayDouble(); ImVector3d dirvec = getDirVec(); ImVector3d midpos3 = getMidPos(); ImVector2d shellPos2 = new ImVector2d(shell.midx, shell.midy); double invShellMajor2 = 1.0 / (shell.major * shell.major); double invShellMinor2 = 1.0 / (shell.minor * shell.minor); // double curZ=integrator.curZ.doubleValue(); // Calculate distances for (int ay = 0; ay < integrator.pixels.getHeight(); ay++) { int lineIndex = lenMap.getRowIndex(ay); for (int ax = 0; ax < integrator.pixels.getWidth(); ax++) { // double worldAX=integrator.stack.transformImageWorldX(ax); // double worldAY=integrator.stack.transformImageWorldY(ay); Vector3d pos2prim = integrator.stack.transformImageWorld(new Vector3d(ax, ay, integrator.curZint)); final ImVector2d pos2 = new ImVector2d(pos2prim.x, pos2prim.y); // new ImVector2(worldAX,worldAY); // final ImVector2 pos2 = new ImVector2(worldAX,worldAY); final ImVector3d pos3 = new ImVector3d(pos2prim.x, pos2prim.y, pos2prim.z); // final ImVector3d pos3 = new ImVector3d(pos2.x,pos2.y,curZ); // Check if this is within ellipse boundary final ImVector2d elip = pos2.sub(shellPos2).rotate(shell.angle); // TODO angle? what? double len; if (1 >= elip.y * elip.y * invShellMinor2 + elip.x * elip.x * invShellMajor2) { // xy . dirvecx = cos(alpha) ||xy|| ||dirvecx|| len = pos3.sub(midpos3).dot(dirvec) + 0.5; // goes from -0.5 to 0.5 before addition if using proper ellipse. projection makes it // wrong!!! } else len = -1; lenMapArr[lineIndex + ax] = len; } } } // Integrate area, separate into slices and background // TODO: have we really really checked that this is done properly? for (int y = 0; y < integrator.pixels.getHeight(); y++) { int lineIndex = integrator.pixels.getRowIndex(y); for (int x = 0; x < integrator.pixels.getWidth(); x++) { int i = lineIndex + x; double len = lenMapArr[i]; int sliceNum = (int) (len * numSubDiv); // may need to bound in addition int thisPixelValue = integrator.pixelsLine[i]; if (sliceNum >= 0 && sliceNum < sliceExp.length) { sliceExp[sliceNum] += thisPixelValue; sliceVol[sliceNum]++; curBgInside.add(thisPixelValue); } else if (len == -1) // so things close the embryo will not be considered - likely too bright { // Measure background. It's all the pixels outside the embryo curBgOutside.add(thisPixelValue); // curBgInt += thisPixelValue; // curBgVol++; } } } }