Exemple #1
0
def iaasf(f, SEQ="OC", b=None, n=1):
    from iasesum import iasesum
    from iaopen import iaopen
    from iaclose import iaclose
    from iasecross import iasecross
    if b is None:
        b = iasecross(None)

    SEQ=upper(SEQ)
    y = f
    if SEQ == 'OC':
        for i in range(1,n+1):
            nb = iasesum(b,i)
            y = iaopen( iaclose(y,nb),nb)
    elif SEQ == 'CO':
        for i in range(1,n+1):
            nb = iasesum(b,i)
            y = iaclose( iaopen(y,nb),nb)
    elif SEQ == 'OCO':
        for i in range(1,n+1):
            nb = iasesum(b,i)
            y = iaopen( iaclose( iaopen(y,nb),nb),nb)
    elif SEQ == 'COC':
        for i in range(1,n+1):
            nb = iasesum(b,i)
            y = iaclose( iaopen( iaclose(y,nb),nb),nb)

    return y
Exemple #2
0
def iasedisk(r=3, DIM="2D", METRIC="EUCLIDEAN", FLAT="FLAT", h=0):
    from iabinary import iabinary
    from iasecross import iasecross
    from iasedil import iasedil
    from iasesum import iasesum
    from iasebox import iasebox
    from iaintersec import iaintersec
    from iagray import iagray

    METRIC = upper(METRIC)
    FLAT   = upper(FLAT)
    assert DIM=='2D','Supports only 2D structuring elements'
    if FLAT=='FLAT': y = iabinary([1])
    else:            y = int32([h])
    if r==0: return y
    if METRIC == 'CITY-BLOCK':
        if FLAT == 'FLAT':
            b = iasecross(1)
        else:
            b = int32([[-2147483647, 0,-2147483647],
                       [          0, 1,          0],
                       [-2147483647, 0,-2147483647]])
        return iasedil(y,iasesum(b,r))
    elif METRIC == 'CHESSBOARD':
        if FLAT == 'FLAT':
            b = iasebox(1)
        else:
            b = int32([[1,1,1],
                       [1,1,1],
                       [1,1,1]])
        return iasedil(y,iasesum(b,r))
    elif METRIC == 'OCTAGON':
        if FLAT == 'FLAT':
            b1,b2 = iasebox(1),iasecross(1)
        else:
            b1 = int32([[1,1,1],[1,1,1],[1,1,1]])
            b2 = int32([[-2147483647, 0,-2147483647],
                        [          0, 1,          0],
                        [-2147483647, 0,-2147483647]])
        if r==1: return b1
        else:    return iasedil( iasedil(y,iasesum(b1,r/2)) ,iasesum(b2,(r+1)/2))
    elif METRIC == 'EUCLIDEAN':
        v = arange(-r,r+1)
        x = resize(v, (len(v), len(v)))
        y = transpose(x)
        Be = iabinary(sqrt(x*x + y*y) <= (r+0.5))
        if FLAT=='FLAT':
            return Be
        be = h + int32( sqrt( maximum((r+0.5)*(r+0.5) - (x*x) - (y*y),0)))
        be = iaintersec( iagray(Be,'int32'),be)
        return be
    else:
        assert 0,'Non valid metric'


    return B
Exemple #3
0
def iasedisk(r=3, DIM="2D", METRIC="EUCLIDEAN", FLAT="FLAT", h=0):
    from iabinary import iabinary
    from iasecross import iasecross
    from iasedil import iasedil
    from iasesum import iasesum
    from iasebox import iasebox
    from iaintersec import iaintersec
    from iagray import iagray

    METRIC = METRIC.upper()
    FLAT = FLAT.upper()
    assert DIM == '2D', 'Supports only 2D structuring elements'
    if FLAT == 'FLAT': y = iabinary([1])
    else: y = int32([h])
    if r == 0: return y
    if METRIC == 'CITY-BLOCK':
        if FLAT == 'FLAT':
            b = iasecross(1)
        else:
            b = int32([[-2147483647, 0, -2147483647], [0, 1, 0],
                       [-2147483647, 0, -2147483647]])
        return iasedil(y, iasesum(b, r))
    elif METRIC == 'CHESSBOARD':
        if FLAT == 'FLAT':
            b = iasebox(1)
        else:
            b = int32([[1, 1, 1], [1, 1, 1], [1, 1, 1]])
        return iasedil(y, iasesum(b, r))
    elif METRIC == 'OCTAGON':
        if FLAT == 'FLAT':
            b1, b2 = iasebox(1), iasecross(1)
        else:
            b1 = int32([[1, 1, 1], [1, 1, 1], [1, 1, 1]])
            b2 = int32([[-2147483647, 0, -2147483647], [0, 1, 0],
                        [-2147483647, 0, -2147483647]])
        if r == 1: return b1
        else:
            return iasedil(iasedil(y, iasesum(b1, r / 2)),
                           iasesum(b2, (r + 1) / 2))
    elif METRIC == 'EUCLIDEAN':
        v = arange(-r, r + 1)
        x = resize(v, (len(v), len(v)))
        y = transpose(x)
        Be = iabinary(sqrt(x * x + y * y) <= (r + 0.5))
        if FLAT == 'FLAT':
            return Be
        be = h + int32(
            sqrt(maximum((r + 0.5) * (r + 0.5) - (x * x) - (y * y), 0)))
        be = iaintersec(iagray(Be, 'int32'), be)
        return be
    else:
        assert 0, 'Non valid metric'

    return B
Exemple #4
0
def iaskelm(f, B=iasecross(), option="binary"):
    from iaisbinary import iaisbinary
    from ialimits import ialimits
    from iagray import iagray
    from iaintersec import iaintersec
    from iasesum import iasesum
    from iaero import iaero
    from iaisequal import iaisequal
    from iaopenth import iaopenth
    from iasedil import iasedil
    from iaunion import iaunion
    from iabinary import iabinary
    from iapad import iapad
    from iaunpad import iaunpad

    assert iaisbinary(f),'Input binary image only'
    option = upper(option)
    f = iapad(f,B)
    print f
    k1,k2 = ialimits(f)
    y = iagray( iaintersec(f, k1),'uint16')
    iszero = asarray(y)
    nb = iasesum(B,0)
    for r in range(1,65535):
        ero = iaero( f, nb)
        if iaisequal(ero, iszero): break
        f1 = iaopenth( ero, B)
        nb = iasedil(nb, B)
        y = iaunion(y, iagray(f1,'uint16',r))
    if option == 'BINARY':
        y = iabinary(y)
    y = iaunpad(y,B)
    return y
Exemple #5
0
def iaskelm(f, B=iasecross(), option="binary"):
    from iaisbinary import iaisbinary
    from ialimits import ialimits
    from iagray import iagray
    from iaintersec import iaintersec
    from iasesum import iasesum
    from iaero import iaero
    from iaisequal import iaisequal
    from iaopenth import iaopenth
    from iasedil import iasedil
    from iaunion import iaunion
    from iabinary import iabinary
    from iapad import iapad
    from iaunpad import iaunpad

    assert iaisbinary(f), 'Input binary image only'
    option = upper(option)
    f = iapad(f, B)
    print f
    k1, k2 = ialimits(f)
    y = iagray(iaintersec(f, k1), 'uint16')
    iszero = asarray(y)
    nb = iasesum(B, 0)
    for r in range(1, 65535):
        ero = iaero(f, nb)
        if iaisequal(ero, iszero): break
        f1 = iaopenth(ero, B)
        nb = iasedil(nb, B)
        y = iaunion(y, iagray(f1, 'uint16', r))
    if option == 'BINARY':
        y = iabinary(y)
    y = iaunpad(y, B)
    return y
Exemple #6
0
def iaopentransf(f,
                 type='OCTAGON',
                 n=65535,
                 Bc=iasecross(),
                 Buser=iasecross()):
    from iaisbinary import iaisbinary
    from iabinary import iabinary
    from iaisequal import iaisequal
    from iaopen import iaopen
    from iasesum import iasesum
    from iasedisk import iasedisk
    from iaaddm import iaaddm
    from iagray import iagray
    from iagrain import iagrain
    from ialabel import ialabel

    assert iaisbinary(f), 'Error: input image is not binary'
    type = upper(type)
    rec_flag = find(type, '-REC')
    if rec_flag != -1:
        type = type[:rec_flag]  # remove the -rec suffix
    flag = not ((type == 'OCTAGON') or (type == 'CHESSBOARD') or
                (type == 'CITY-BLOCK'))
    if not flag:
        n = min(n, min(f.shape))
    elif type == 'LINEAR-H':
        se = iabinary([1, 1, 1])
        n = min(n, f.shape[1])
    elif type == 'LINEAR-V':
        se = iabinary([[1], [1], [1]])
        n = min(n, f.shape[0])
    elif type == 'LINEAR-45R':
        se = iabinary([[0, 0, 1], [0, 1, 0], [1, 0, 0]])
        n = min(n, min(f.shape))
    elif type == 'LINEAR-45L':
        se = iabinary([[1, 0, 0], [0, 1, 0], [0, 0, 1]])
        n = min(n, min(f.shape))
    elif type == 'USER':
        se = Buser
        n = min(n, min(f.shape))
    else:
        print 'Error: only accepts OCTAGON, CHESSBOARD, CITY-BLOCK, LINEAR-H, LINEAR-V, LINEAR-45R, LINEAR-45L, or USER as type, or with suffix -REC.'
        return []
    k = 0
    y = uint16(zeros(f.shape))
    a = iabinary([1])
    z = iabinary([0])
    while not (iaisequal(a, z) or (k >= n)):
        print 'processing r=', k
        if flag:
            a = iaopen(f, iasesum(se, k))
        else:
            a = iaopen(f, iasedisk(k, '2D', type))
        y = iaaddm(y, iagray(a, 'uint16', 1))
        k = k + 1
    if rec_flag != -1:
        y = iagrain(ialabel(f, Bc), y, 'max')

    return y
Exemple #7
0
def iacbisector(f, B, n):
    from iaintersec import iaintersec
    from iasesum import iasesum
    from iaero import iaero
    from iacdil import iacdil
    from iasubm import iasubm
    from iaunion import iaunion

    y = iaintersec(f, 0)
    for i in range(n):
        nb = iasesum(B, i)
        nbp = iasesum(B, i + 1)
        f1 = iaero(f, nbp)
        f2 = iacdil(f1, f, B, n)
        f3 = iasubm(iaero(f, nb), f2)
        y = iaunion(y, f3)
    return y
Exemple #8
0
def iacbisector(f, B, n):
    from iaintersec import iaintersec
    from iasesum import iasesum
    from iaero import iaero
    from iacdil import iacdil
    from iasubm import iasubm
    from iaunion import iaunion

    y = iaintersec(f,0)
    for i in range(n):
        nb = iasesum(B,i)
        nbp = iasesum(B,i+1)
        f1 = iaero(f,nbp)
        f2 = iacdil(f1,f,B,n)
        f3 = iasubm( iaero(f,nb),f2)
        y  = iaunion(y,f3)
    return y
Exemple #9
0
def iasecross(r=1):
    from iasesum import iasesum
    from iabinary import iabinary

    B = iasesum( iabinary([[0,1,0],
                           [1,1,1],
                           [0,1,0]]),r)
    return B
Exemple #10
0
def iaopentransf(f, type='OCTAGON', n=65535, Bc=iasecross(), Buser=iasecross()):
    from iaisbinary import iaisbinary
    from iabinary import iabinary
    from iaisequal import iaisequal
    from iaopen import iaopen
    from iasesum import iasesum
    from iasedisk import iasedisk
    from iaaddm import iaaddm
    from iagray import iagray
    from iagrain import iagrain
    from ialabel import ialabel

    assert iaisbinary(f),'Error: input image is not binary'
    type = upper(type)
    rec_flag = find(type,'-REC')
    if rec_flag != -1:
        type = type[:rec_flag] # remove the -rec suffix
    flag = not ((type == 'OCTAGON')  or
                (type == 'CHESSBOARD') or
                (type == 'CITY-BLOCK'))
    if not flag:
        n  = min(n,min(f.shape))
    elif  type == 'LINEAR-H':
        se = iabinary([1, 1, 1])
        n  = min(n,f.shape[1])
    elif  type =='LINEAR-V':
        se = iabinary([[1],[1],[1]])
        n  = min(n,f.shape[0])
    elif  type == 'LINEAR-45R':
        se = iabinary([[0, 0, 1],[0, 1, 0],[1, 0, 0]])
        n  = min(n,min(f.shape))
    elif  type == 'LINEAR-45L':
        se = iabinary([[1, 0, 0],[0, 1, 0],[0, 0, 1]])
        n  = min(n,min(f.shape))
    elif  type == 'USER':
        se = Buser
        n  = min(n,min(f.shape))
    else:
        print 'Error: only accepts OCTAGON, CHESSBOARD, CITY-BLOCK, LINEAR-H, LINEAR-V, LINEAR-45R, LINEAR-45L, or USER as type, or with suffix -REC.'
        return []
    k = 0
    y = uint16(zeros(f.shape))
    a = iabinary([1])
    z = iabinary([0])
    while not ( iaisequal(a,z) or (k>=n)):
        print 'processing r=',k
        if flag:
            a = iaopen(f,iasesum(se,k))
        else:
            a = iaopen(f,iasedisk(k,'2D',type))
        y = iaaddm(y, iagray(a,'uint16',1))
        k = k+1
    if rec_flag != -1:
        y = iagrain( ialabel(f,Bc),y,'max')

    return y
Exemple #11
0
def iasebox(r=1):
    from iasesum import iasesum
    from iabinary import iabinary


    B = iasesum( iabinary([[1,1,1],
                          [1,1,1],
                          [1,1,1]]),r)


    return B
Exemple #12
0
def iaasfrec(f, SEQ="OC", b=iasecross(), bc=iasecross(), n=1):
    from iasesum import iasesum
    from iacloserec import iacloserec
    from iaopenrec import iaopenrec

    SEQ = SEQ.upper()
    y = f
    if SEQ == 'OC':
        for i in range(1, n + 1):
            nb = iasesum(b, i)
            y = iacloserec(y, nb, bc)
            y = iaopenrec(y, nb, bc)
    elif SEQ == 'CO':
        for i in range(1, n + 1):
            nb = iasesum(b, i)
            y = iaopenrec(y, nb, bc)
            y = iacloserec(y, nb, bc)
    else:
        assert 0, 'Only accepts OC or CO for SEQ parameter'

    return y
Exemple #13
0
def iaasfrec(f, SEQ="OC", b=iasecross(), bc=iasecross(), n=1):
    from iasesum import iasesum
    from iacloserec import iacloserec
    from iaopenrec import iaopenrec

    SEQ = upper(SEQ)
    y = f
    if SEQ == "OC":
        for i in range(1, n + 1):
            nb = iasesum(b, i)
            y = iacloserec(y, nb, bc)
            y = iaopenrec(y, nb, bc)
    elif SEQ == "CO":
        for i in range(1, n + 1):
            nb = iasesum(b, i)
            y = iaopenrec(y, nb, bc)
            y = iacloserec(y, nb, bc)
    else:
        assert 0, "Only accepts OC or CO for SEQ parameter"

    return y
Exemple #14
0
def iabshow(f1, f2=None, f3=None, factor=17):
    from iabinary import iabinary
    from iaframe import iaframe
    from iadil import iadil
    from iaunion import iaunion
    from iasedisk import iasedisk
    from iaserot import iaserot
    from iasecross import iasecross
    from iasesum import iasesum

    assert f1.dtype == bool, 'f1 must be boolean image'
    factor = max(factor, 9)
    hfactor = factor / 2
    if size(f1.shape) == 1:
        f1 = f1[newaxis, :]
        if f2 != None: f2 = f2[newaxis, :]
        if f3 != None: f3 = f3[newaxis, :]
    bz = zeros(factor * array(f1.shape)).astype(bool)
    b0 = asarray(bz)
    b0[hfactor::factor, hfactor::factor] = f1
    fr1 = iaframe(zeros((factor, factor), bool))
    fr1 = iadil(b0, fr1)

    if f2 != None:
        assert f1.shape == f2.shape, 'f1 and f2 must have same shape'
        b1 = asarray(bz)
        b1[hfactor::factor, hfactor::factor] = f2
        fr2 = iadil(b1, iasedisk(hfactor - 4))
        fr1 = iaunion(fr1, fr2)

        if f3 != None:
            assert f1.shape == f3.shape, 'f1 and f3 must have same shape'
            bz[hfactor::factor, hfactor::factor] = f3
            fr3 = iadil(bz, iasesum(iaserot(iasecross(1), 45), hfactor - 1))
            fr1 = iaunion(fr1, fr3)
    return fr1
Exemple #15
0
def iabshow(f1, f2=None, f3=None, factor=17):
    from iabinary import iabinary
    from iaframe import iaframe
    from iadil import iadil
    from iaunion import iaunion
    from iasedisk import iasedisk
    from iaserot import iaserot
    from iasecross import iasecross
    from iasesum import iasesum

    assert f1.dtype == bool, 'f1 must be boolean image'
    factor = max(factor,9)
    hfactor = factor/2
    if size(f1.shape) == 1:
       f1 = f1[newaxis,:]
       if f2 != None: f2 = f2[newaxis,:]
       if f3 != None: f3 = f3[newaxis,:]
    bz = zeros(factor * array(f1.shape)).astype(bool)
    b0 = asarray(bz)
    b0[hfactor::factor,hfactor::factor] = f1
    fr1 = iaframe(zeros((factor,factor),bool))
    fr1 = iadil(b0,fr1)

    if f2 != None:
      assert f1.shape == f2.shape, 'f1 and f2 must have same shape'
      b1 = asarray(bz)
      b1[hfactor::factor,hfactor::factor] = f2
      fr2 = iadil(b1,iasedisk(hfactor - 4))
      fr1 = iaunion(fr1,fr2)

      if f3 != None:
        assert f1.shape == f3.shape, 'f1 and f3 must have same shape'
        bz[hfactor::factor,hfactor::factor] = f3
        fr3 = iadil(bz, iasesum(iaserot(iasecross(1),45),hfactor - 1))
        fr1 = iaunion(fr1,fr3)
    return fr1
Exemple #16
0
def iasecross(r=1):
    from iasesum import iasesum
    from iabinary import iabinary

    B = iasesum(iabinary([[0, 1, 0], [1, 1, 1], [0, 1, 0]]), r)
    return B