예제 #1
0
  /**
   * @param permuted
   * @return
   */
  private static IntervalIterator createIntervalIterator(
      final RandomAccessibleInterval<?> permuted) {
    final long[] dims = new long[permuted.numDimensions()];
    permuted.dimensions(dims);

    dims[0] = 1;
    dims[1] = 1;

    final IntervalIterator ii = new IntervalIterator(dims);
    return ii;
  }
    public Cursor(final RandomAccessibleInterval<U> ra) {
      m_ra = ra.randomAccess();

      m_numPixel = numPixels(ra);

      m_lastPos = new long[ra.numDimensions()];
      for (int i = 0; i < m_lastPos.length; i++) {
        m_lastPos[i] = ra.dimension(i) - 1;
      }

      m_breaks = new long[ra.numDimensions()];
      ra.dimensions(m_breaks);

      for (int i = 1; i < m_breaks.length; i++) {
        m_breaks[i] *= m_breaks[i - 1];
      }

      setToOrigin();
    }
예제 #3
0
 /** Compute the inverse Hessian matrix from the the steepest descent images. */
 public static <T extends RealType<T>> double[][] computeInverseHessian(
     final RandomAccessibleInterval<T> descent) {
   final int n = descent.numDimensions() - 1;
   final int numParameters = (int) descent.dimension(n);
   final long[] dim = new long[n + 1];
   descent.dimensions(dim);
   dim[n] = 1;
   final LocalizingIntervalIterator pos = new LocalizingIntervalIterator(dim);
   final RandomAccess<T> r = descent.randomAccess();
   final double[] deriv = new double[numParameters];
   final double[][] H = new double[numParameters][numParameters];
   while (pos.hasNext()) {
     pos.fwd();
     r.setPosition(pos);
     for (int p = 0; p < numParameters; ++p) {
       deriv[p] = r.get().getRealDouble();
       r.fwd(n);
     }
     for (int i = 0; i < numParameters; ++i)
       for (int j = 0; j < numParameters; ++j) H[i][j] += deriv[i] * deriv[j];
   }
   return new Matrix(H).inverse().getArray();
 }