Example #1
0
def test_non_array_input():
    ramp = np.linspace(-100, 100, 500).tolist()
    reflected = reflect(ramp, 30, 40)

    # Check boundaries
    assert not np.any(reflected < 30)
    assert not np.any(reflected > 40)
Example #2
0
def test_non_array_input():
    ramp = np.linspace(-100, 100, 500).tolist()
    reflected = reflect(ramp, 30, 40)

    # Check boundaries
    assert not np.any(reflected < 30)
    assert not np.any(reflected > 40)
Example #3
0
def _upsample_columns(X, method=None):
    """
    The centre of columns of X, an M-columned matrix, are assumed to have co-ordinates
    { 0, 1, 2, ... , M-1 } which means that the up-sampled matrix's columns should sample
    from { -0.25, 0.25, 0.75, ... , M-1.25 }. We can view that as an interleaved set of teo
    *convolutions* of X. The first, A, using a kernel equivalent to sampling the { -0.25, 0.75,
    1.75, 2.75, ... M-1.25 } columns and the second, B, sampling the { 0.25, 1.25, ... , M-0.75 }
    columns.
    """
    if method is None:
        method = 'lanczos'
    
    X = np.atleast_2d(asfarray(X))
    
    out_shape = list(X.shape)
    out_shape[1] *= 2
    output = np.zeros(out_shape, dtype=X.dtype)
    
    # Centres of sampling for A and B convolutions
    M = X.shape[1]
    A_columns = np.linspace(-0.25, M-1.25, M)
    B_columns = A_columns + 0.5
    
    # For A columns sample at x = ceil(x) - 0.25 with ceil(x) = { 0, 1, 2, ..., M-1 }
    # For B columns sample at x = floor(x) + 0.25 with floor(x) = { 0, 1, 2, ..., M-1 }
    int_columns = np.linspace(0, M-1, M)
    
    if method == 'lanczos':
        # Lanczos kernel width
        a = 3.0
        sample_offsets = np.arange(-a, a+1)
       
        # For A: if i = ceil(x) + di, => ceil(x) - i = -0.25 - di
        # For B: if i = floor(x) + di, => floor(x) - i = 0.25 - di
        l_as = np.sinc(-0.25-sample_offsets)*np.sinc((-0.25-sample_offsets)/a)   
        l_bs = np.sinc(0.25-sample_offsets)*np.sinc((0.25-sample_offsets)/a)
    elif method == 'nearest':
        # Nearest neighbour kernel width is 1
        sample_offsets = [0,]
        l_as = l_bs = [1,]
    elif method == 'bilinear':
        # Bilinear kernel width is technically 2 but we need to offset the kernels differently
        # for A and B columns:
        sample_offsets = [-1,0,1]
        l_as = [0.25, 0.75, 0]
        l_bs = [0, 0.75, 0.25]
    else:
        raise ValueError('Unknown interpolation mode: {0}'.format(mode))
    
    # Convolve
    for di, l_a, l_b in zip(sample_offsets, l_as, l_bs):
        columns = reflect(int_columns + di, -0.5, M-0.5).astype(np.int)
        
        output[:,0::2,...] += l_a * X[:,columns,...]
        output[:,1::2,...] += l_b * X[:,columns,...]
    
    return output
Example #4
0
def _sample_clipped(im, xs, ys):
    """Truncated and symmatric sampling."""
    sym_xs = reflect(xs, -0.5, im.shape[1]-0.5).astype(np.int)
    sym_ys = reflect(ys, -0.5, im.shape[0]-0.5).astype(np.int)
    return im[sym_ys, sym_xs, ...]
Example #5
0
def setup():
    global ramp, reflected

    # Create a simple linear ramp and reflect it
    ramp = np.linspace(-100, 100, 500)
    reflected = reflect(ramp, 30, 40)
Example #6
0
def _sample_clipped(im, xs, ys):
    """Truncated and symmatric sampling."""
    sym_xs = reflect(xs, -0.5, im.shape[1] - 0.5).astype(np.int)
    sym_ys = reflect(ys, -0.5, im.shape[0] - 0.5).astype(np.int)
    return im[sym_ys, sym_xs, ...]
Example #7
0
def _upsample_columns(X, method=None):
    """
    The centre of columns of X, an M-columned matrix, are assumed to have co-ordinates
    { 0, 1, 2, ... , M-1 } which means that the up-sampled matrix's columns should sample
    from { -0.25, 0.25, 0.75, ... , M-1.25 }. We can view that as an interleaved set of teo
    *convolutions* of X. The first, A, using a kernel equivalent to sampling the { -0.25, 0.75,
    1.75, 2.75, ... M-1.25 } columns and the second, B, sampling the { 0.25, 1.25, ... , M-0.75 }
    columns.
    """
    if method is None:
        method = 'lanczos'

    X = np.atleast_2d(asfarray(X))

    out_shape = list(X.shape)
    out_shape[1] *= 2
    output = np.zeros(out_shape, dtype=X.dtype)

    # Centres of sampling for A and B convolutions
    M = X.shape[1]
    A_columns = np.linspace(-0.25, M - 1.25, M)
    B_columns = A_columns + 0.5

    # For A columns sample at x = ceil(x) - 0.25 with ceil(x) = { 0, 1, 2, ..., M-1 }
    # For B columns sample at x = floor(x) + 0.25 with floor(x) = { 0, 1, 2, ..., M-1 }
    int_columns = np.linspace(0, M - 1, M)

    if method == 'lanczos':
        # Lanczos kernel width
        a = 3.0
        sample_offsets = np.arange(-a, a + 1)

        # For A: if i = ceil(x) + di, => ceil(x) - i = -0.25 - di
        # For B: if i = floor(x) + di, => floor(x) - i = 0.25 - di
        l_as = np.sinc(-0.25 - sample_offsets) * np.sinc(
            (-0.25 - sample_offsets) / a)
        l_bs = np.sinc(0.25 - sample_offsets) * np.sinc(
            (0.25 - sample_offsets) / a)
    elif method == 'nearest':
        # Nearest neighbour kernel width is 1
        sample_offsets = [
            0,
        ]
        l_as = l_bs = [
            1,
        ]
    elif method == 'bilinear':
        # Bilinear kernel width is technically 2 but we need to offset the kernels differently
        # for A and B columns:
        sample_offsets = [-1, 0, 1]
        l_as = [0.25, 0.75, 0]
        l_bs = [0, 0.75, 0.25]
    else:
        raise ValueError('Unknown interpolation mode: {0}'.format(mode))

    # Convolve
    for di, l_a, l_b in zip(sample_offsets, l_as, l_bs):
        columns = reflect(int_columns + di, -0.5, M - 0.5).astype(np.int)

        output[:, 0::2, ...] += l_a * X[:, columns, ...]
        output[:, 1::2, ...] += l_b * X[:, columns, ...]

    return output
Example #8
0
def setup():
    global ramp, reflected

    # Create a simple linear ramp and reflect it
    ramp = np.linspace(-100, 100, 500)
    reflected = reflect(ramp, 30, 40)