示例#1
0
def get_initial_phase(hologram, wavelength=1):
    fringes = hologram / float(hologram.ptp())
    fringes = (fringes + fringes.min()) * 2 - 1
    image_dft = get_shifted_dft(fringes)
    cos_alpha, cos_beta = calculate_director_cosines(image_dft, wavelength, (1, 1))
    maxrow = fringes.shape[0]
    maxcol = fringes.shape[1]
    row, col = np.ogrid[:maxrow:1., :maxcol:1.]
    plane = cos_alpha * col + cos_beta * row

    def fitness((alpha, beta, offset)):
        alpha = (sigmoid(alpha) - 0.5) * 2 ** 2
        beta = (sigmoid(beta) - 0.5) * 2 ** 2
        offset = sigmoid(offset) * tau / 2
        correction = cos_alpha * col + cos_beta * row + offset
        sintetic_fringes = get_fringes(plane + correction, wavelength)
        score = np.sum(np.fabs(fringes - sintetic_fringes))
        print(alpha, beta, offset, score)
        return score
    alpha, beta, offset = generic_minimizer(fitness, [0, 0, 0])

    alpha = (sigmoid(alpha) - 0.5) * 2 ** 2
    beta = (sigmoid(beta) - 0.5) * 2 ** 2
    offset = sigmoid(offset) * tau / 2
    correction = alpha * col + beta * row + offset
    plane = plane + correction
    return plane
示例#2
0
def phase_match(phase1, phase2):
    def diference(k):
        distance = ((phase1 - phase2 + k) ** 2).sum()
        return distance

    best_k = float(generic_minimizer(diference, 1))
    return best_k
示例#3
0
def get_initial_phase(hologram, wavelength=1):
    fringes = hologram / float(hologram.ptp())
    fringes = (fringes + fringes.min()) * 2 - 1
    image_dft = get_shifted_dft(fringes)
    cos_alpha, cos_beta = calculate_director_cosines(image_dft, wavelength,
                                                     (1, 1))
    maxrow = fringes.shape[0]
    maxcol = fringes.shape[1]
    row, col = np.ogrid[:maxrow:1., :maxcol:1.]
    plane = cos_alpha * col + cos_beta * row

    def fitness((alpha, beta, offset)):
        alpha = (sigmoid(alpha) - 0.5) * 2**2
        beta = (sigmoid(beta) - 0.5) * 2**2
        offset = sigmoid(offset) * tau / 2
        correction = cos_alpha * col + cos_beta * row + offset
        sintetic_fringes = get_fringes(plane + correction, wavelength)
        score = np.sum(np.fabs(fringes - sintetic_fringes))
        print(alpha, beta, offset, score)
        return score

    alpha, beta, offset = generic_minimizer(fitness, [0, 0, 0])

    alpha = (sigmoid(alpha) - 0.5) * 2**2
    beta = (sigmoid(beta) - 0.5) * 2**2
    offset = sigmoid(offset) * tau / 2
    correction = alpha * col + beta * row + offset
    plane = plane + correction
    return plane
示例#4
0
def get_subtract_paramns(left, right):
    """
    Returns k that minimizes:

        var(left - k * right)
    """
    def diference((k)):
        return (left - k * right).var()

    best_k = float(generic_minimizer(diference, 1))
    return best_k
示例#5
0
def get_subtract_paramns(left, right):
    """
    Returns k that minimizes:

        var(left - k * right)
    """

    def diference((k)):
        return (left - k * right).var()

    best_k = float(generic_minimizer(diference, 1))
    return best_k
示例#6
0
def get_best_contrast_zone(hologram, margin=50, shape=(256, 256)):
    assert shape[0] + 2 * margin <= hologram.shape[0]
    assert shape[1] + 2 * margin <= hologram.shape[1]
    hologram = hologram[margin:-margin, margin:-margin]
    rows = hologram.shape[0] - shape[0] + 1
    cols = hologram.shape[1] - shape[1] + 1
    rowsvar = hologram.var(0)
    colsvar = hologram.var(1)
    sumsrowsranges = np.array(
        [rowsvar[top:top + shape[0]].sum() for top in xrange(rows)])
    sumscolsranges = np.array(
        [colsvar[left:left + shape[1]].sum() for left in xrange(cols)])
    toprow = sumsrowsranges.argmax()
    leftcol = sumscolsranges.argmax()
    return hologram[toprow:toprow + shape[0], leftcol:leftcol + shape[1]]


@cache.hybrid(reset=False)
def guess_focus_distance(masked_spectrum,
                         wavelength,
                         (dx, dy),
                         extractor=get_diff_var):
    def fitness(args):
        return extractor(masked_spectrum, args, wavelength, (dx, dy))

    results = []
    for distance in frange(0, .15, 3):
        xend = generic_minimizer(fitness, distance, [optimize.fmin])
        results.append((fitness(xend), xend[0]))
    return sorted(results)[0][1]
示例#7
0
def get_best_contrast_zone(hologram, margin=50, shape=(256, 256)):
    assert shape[0] + 2 * margin <= hologram.shape[0]
    assert shape[1] + 2 * margin <= hologram.shape[1]
    hologram = hologram[margin:-margin, margin:-margin]
    rows = hologram.shape[0] - shape[0] + 1
    cols = hologram.shape[1] - shape[1] + 1
    rowsvar = hologram.var(0)
    colsvar = hologram.var(1)
    sumsrowsranges = np.array([rowsvar[top:top + shape[0]].sum()
        for top in xrange(rows)])
    sumscolsranges = np.array([colsvar[left:left + shape[1]].sum()
        for left in xrange(cols)])
    toprow = sumsrowsranges.argmax()
    leftcol = sumscolsranges.argmax()
    return hologram[toprow:toprow + shape[0], leftcol:leftcol + shape[1]]


@cache.hybrid(reset=False)
def guess_focus_distance(masked_spectrum, wavelength, (dx, dy),
        extractor=get_diff_var):

    def fitness(args):
        return extractor(masked_spectrum, args, wavelength, (dx, dy))

    results = []
    for distance in frange(0, .15, 3):
        xend = generic_minimizer(fitness, distance, [optimize.fmin])
        results.append((fitness(xend), xend[0]))
    return sorted(results)[0][1]