Europe PMC

This website requires cookies, and the limited processing of your personal data in order to function. By using the site you are agreeing to this as outlined in our privacy notice and cookie policy.

Abstract 


Discrete orthogonal moments have been recently introduced in the field of image analysis. It was shown that they have better image representation capability than the continuous orthogonal moments. One problem concerning the use of moments as feature descriptors is the high computational cost, which may limit their application to the problems where the online computation is required. In this paper, we present a new approach for fast computation of the 2-D Tchebichef moments. By deriving some properties of Tchebichef polynomials, and using the image block representation for binary images and intensity slice representation for grayscale images, a fast algorithm is proposed for computing the moments of binary and grayscale images. The theoretical analysis shows that the computational complexity of the proposed method depends upon the number of blocks of the image, thus, it can speed up the computational efficiency as far as the number of blocks is smaller than the image size.

Free full text 


Logo of halLink to Publisher's site
IEEE Trans Image Process. Author manuscript; available in PMC 2011 Dec 12.
Published in final edited form as:
PMCID: PMC3235093
HALMS: HALMS503235
PMID: 20542765

Fast computation of Tchebichef moments for binary and grayscale images

Abstract

Discrete orthogonal moments have been recently introduced in the field of image analysis. It was shown that they have better image representation capability than the continuous orthogonal moments. One problem concerning the use of moments as feature descriptors is the high computational cost, which may limit their application to the problems where the on-line computation is required. In this paper, we present a new approach for fast computation of the two-dimensional Tchebichef moments. By deriving some properties of Tchebichef polynomials, and using the image block representation for binary images and intensity slice representation for gray-scale images, a fast algorithm is proposed for computing the moments of binary and gray-scale images. The theoretical analysis shows that the computational complexity of the proposed method depends on the number of blocks of the image, thus, it can speed up the computational efficiency as far as the number of blocks is smaller than the image size.

Keywords: Algorithms, Image Enhancement, methods, Models, Theoretical, Pattern Recognition, Automated, methods
Keywords: Discrete orthogonal moments, Tchebichef polynomials, fast computation, image block representation, intensity slice representation

I. INTRODUCTION

Moments and moment functions have been extensively used for feature extraction in pattern recognition and object classification [1]–[5]. One important property of the moments is their invariance under affine transformation. The pioneering work on this subject was by Hu [6]. Since then, many applications have been developed, which made use of geometric, complex, rotational and orthogonal moments [7]–[12].

Considerable attention has been paid on the theoretic study and application of the orthogonal moments since they can be easily used to reconstruct the image, and have the minimum information redundancy to represent the image [13]–[17].

Recently, discrete orthogonal moments such as Tchebichef, Krawtchouk, dual Hahn, Racah and Hahn moments have been introduced in image analysis community [18]–[23]. It was shown that they have better image representation capability than the continuous orthogonal moments.

One main difficulty concerning the use of moments as feature descriptors is their high computational complexity. To solve this problem, a number of fast algorithms have been reported in the literature [24]–[39]. Most of them concentrated on the fast computation of geometric moments and continuous orthogonal moments. Less attention has been paid on the fast computation of discrete orthogonal moments [35]–[39]. Wang and Wang [35] proposed a recursive algorithm based on Clenshaw’s recurrence formula to compute the Tchebichef moments. Kotoulas and Andreadis [36] presented a hardware technique based on FPGA for implementing the calculation of Tchebichef moment values. They further proposed a more flexible architecture [37] dealing with various types of moments. Papakostas et al. [38] derived a unified methodology based on the image representation method for efficiently computing the discrete orthogonal moments. Bayraktar et al. [39] proposed an approach that consists of calculating the polynomial coefficients with arbitrary precision.

In this paper, we propose an efficient computation of Tchebichef moments for both binary and gray-scale images. For binary images, by using the image block representation proposed by Spiliotis and Merzios [25], the image moments can be obtained from the moments of all blocks. We further derive some properties of Tchebichef polynomials which can be used to efficiently calculate the moments of each block. The proposed method is then extended to gray-scale images by using the so-called ‘intensity slice representation’ introduced by Papakostas et al. [28].

The rest of the paper is organized as follows. In Section II, we review the definition of Tchebichef moments. Section III gives a brief introduction of the image block representation and the intensity slice representation. In Section IV, we first derive some properties of Tchebichef polynomials, and then propose a fast algorithm for computing the Tchebichef moments for both binary and gray-scale images. The computational complexity is analyzed in Section V and some experimental results are also provided. Section VI concludes the work.

II. Tchebichef moments

The two-dimensional (2-D) Tchebichef moment of order (n+m) of an image intensity function f(x, y) with size N × N is defined as [18], [19]

Tnm=x=0N1y=0N1tn(x)tm(y)f(x,y),
(1)

where tn(x) is the nth order orthonormal Tchebichef polynomial defined by

tn(x)=(1N)nρ(n,N)k=0n(n)k(x)k(1+n)k(k!)2(1N)k,n,x=0,1,,N1.
(2)

Here (a)k is the Pochhammer symbol

(a)k=a(a+1)(a+2)(a+k1),k1and(a)0=1,
(3)

and the squared-norm ρ(n, N) is given by

ρ(n,N)=(N+n)!(2n+1)(Nn1)!.
(4)

Equation (2) can be rewritten as

tn(x)=k=0ncn,k(x)k,
(5)

where

cn,k=(1)kρ(n,N)(n+k)!(nk)!(k!)2(1N)n(1N)k=(1)nρ(n,N)(n+k)!(Nk1)!(nk)!(k!)2(Nn1)!.
(6)

The orthogonality property leads to the following inverse moment transform

f(x,y)=n=0N1m=0N1Tnmtn(x)tm(y).
(7)

If only the moments of order up to (M−1, M−1) are computed, equation (7) is approximated by

f(x,y)=n=0M1m=0M1Tnmtn(x)tm(y).
(8)

III. Representation of binary and gray-scale images

A. Image block representation for binary images

Image block representation (IBR) was introduced by Spiliotis and Mertzios [25] and has been used to achieve a fast computation of geometric moments for binary images.

A binary image, f(x, y), can be represented as a set of blocks, each block corresponding to an object or a part of object. This block is defined as a rectangular area, which gathers a set of connected pixels whose value is included in the same value interval. This area building is briefly reviewed through the following algorithm [25], [28].

Algorithm IBR

  • Step 1 Consider each line y of the image f(x, y) and find object level intervals in line y.
  • Step 2 Compare intervals and blocks that have pixels in line y−1.
  • Step 3 If an interval does not match with any block, this is the beginning of a new block.
  • Step 4 If a block matches with an interval, the end of the block is in the line y.

After applying the algorithm, the binary image is represented as a set of blocks of level one. This block-represented image is described by the relation

f(x,y)={bi,i=0,1,,K1},
(9)

where bi is the ith block and K is the total number of blocks. Each block is described by the coordinates of the upper left and down right corner in vertical and horizontal axes.

B. Partial intensity slice representation for gray-scale images

Papakostas et al. [28] recently introduced a new image representation scheme, known as the intensity slice representation (ISR), which decomposes a gray-scale image f(x, y) into a series of two-level images fi(x, y), that is

f(x,y)=i=1Lfi(x,y),
(10)

where L is the number of slices (equal to the number of different intensity values) and fi(x, y) is the intensity function of the ith slice. In the case of a binary image, we have L = 1, so that, f(x, y) = f1(x, y).

Once a gray-scale image is decomposed into several slices according to the ISR scheme, each slice can be considered as a two-level image where the IBR algorithm can be applied. Instead of applying the IBR algorithm to each slice, Papakostas et al. [28] proposed to use the partial IBR (PIBR) algorithm. The PIBR algorithm consists of one pass of the image and a bookkeeping process, which can be described as follows.

Algorithm PIBR

  • Step 1 Consider each line y of the image f(x, y) and find object level intervals for each intensity value that exists in line y.
  • Step 2 Compare intervals and blocks that have the same intensity line y−1.
  • Step 3 If an interval does not match with any block of the same intensity, this is the beginning of a new block.
  • Step 4 If a block matches with an interval of the same intensity, the end of the block is in the line y.

After applying the algorithm, the gray-scale image f(x, y) can be redefined in terms of blocks of different intensities as

f(x,y)={fi(x,y),i=1,2,,L},fi(x,y)={bij,j=0,1,,Ki1}.
(11)

where bij is the jth block of slice i and Ki is the number of image blocks having intensity fi. Each block is described by the coordinates of the upper left and down right corner in vertical and horizontal axes.

IV. Fast computation of Tchebichef moments

In this section, we first derive some properties of orthonormal Tchebichef polynomials, and then develop an efficient algorithm for computing the Tchebichef moments.

A. Some properties of orthonormal Tchebichef polynomials

Theorem 1

Let Pn(x)=k=0ncn,k(x)k, where (−x)k is defined by (3) and cn,n ≠ 0, n = 0, 1, …, N−1, be a set of polynomials. Assume for integer numbers a and x, we have

Pn(a+x)=k=0nl=0nkgl(n,k)(a)lPk(x),
(12)

then the coefficients gl(n, k) are given by

gl(n,k)=s=knl(l+ss)cn,l+sds,k,
(13)

where DN =(dn, k), with 0 ≤ knN−1, is the inverse of the lower triangular matrix CN =(cn, k) of size N × N, i.e., DN=CN1.

The proof of Theorem 1 is deferred to Appendix. In order to apply Theorem 1, an essential step consists of finding the inverse matrix DN when the original matrix CN is known. In this paper, we are interested in the use of Tchebichef polynomials. For the orthonormal Tchebichef polynomials tn(x) defined by (5) and (6), we have the following Proposition.

Proposition 1

For the lower triangular matrix CN whose elements cn, k are defined by (6), the elements dn, k of the inverse matrix DN are given by

dn,k=(1)nρ(k,N)(2k+1)(n!)2(Nk1)!(n+k+1)!(nk)!(Nn1)!.
(14)

The proof of Proposition 1 is deferred to Appendix. Based on Theorem 1 and Proposition 1, we can easily derive the following result.

Corollary 1

For the orthonormal Tchebichef polynomials, letting

tn(a+x)=k=0nl=0nkgl(n,k)(a)ltk(x),
(15)

then we have

gl(n,k)=(1)n(2k+1)(N1k)!l!(N1n)!ρ(k,N)ρ(n,N)s=knl(1)ss!(n+l+s)!(N1sl)!(l+s)!(nls)!(s+k+1)!(sk)!(N1s)!,0kn.
(16)

For the purpose of this paper, we are particularly interested in the case where a=1 in (15). By the definition of (a)k given by (3), we have (−1)0 = 1, (−1)1 = −1, and (−1)l = 0 for l ≥ 2. Using these properties, equation (15) becomes

tn(x+1)=k=0ng0(n,k)tk(x)k=0n1g1(n,k)tk(x),
(17)

where gl(n, k), l = 0, 1, defined by (16), are given as

g0(n,k)=(1)n(2k+1)(N1k)!(N1n)!ρ(k,N)ρ(n,N)s=kn(1)s(n+s)!(ns)!(sk)!(s+k+1)!,0kn,
(18)

g1(n,k)=(1)n(2k+1)(N1k)!(N1n)!ρ(k,N)ρ(n,N)s=kn1(1)s(n+1+s)!(s+1)(N1s)(n1s)!(s+k+1)!(sk)!=(2k+1)(N1k)!(N1n)!ρ(k,N)ρ(n,N)s=0nk1(1)s(2ns)!(ns)(Nn+s)s!(n+ks)!(n1ks)!=s=0nk1Bn,k,s,0kn1,
(19)

where

Bn,k,s=(1)s(2k+1)(2ns)!(ns)(Nn+s)s!(n+ks)!(n1ks)!(N1k)!(N1n)!ρ(k,N)ρ(n,N).
(20)

For the computation of g0(n, k), we have the following result.

Theorem 2

For g0(n, k) given by (18), we have

g0(n,n)=1,g0(n,k)=0for0kn1.
(21)

The proof of Theorem 2 is deferred to Appendix.

Using (21), equation (17) becomes

tn(x+1)=tn(x)k=0n1g1(n,k)tk(x).
(22)

We are now ready to propose a new approach for efficiently computing the Tchebichef moments defined by (1). This is the subject of the following subsections.

B. Fast computation of Tchebichef moments for binary images

For a binary image f(x, y) represented by K blocks, as described in (10), equation (1) can be rewritten as

Tnm=i=0K1x=x1,bix2,biy=y1,biy2,bitn(x)tm(y)=i=0K1Tnmbi,
(23)

where (x1,bi, y1,bi) and (x2,bi, y2,bi) are respectively the left-up and right-bottom coordinates of the block bi, and Tnmbi is the moment of block bi given by

Tnmbi=x=x1,bix2,biy=y1,biy2,bitn(x)tm(y)=[x=x1,bix2,bitn(x)][y=y1,biy2,bitm(y)]=Sn(x1,bi,x2,bi)Sm(y1,bi,y2,bi),
(24)

with

Sn(x1,bi,x2,bi)=x=x1,bix2,bitn(x),Sm(y1,bi,y2,bi)=y=y1,biy2,bitm(y).
(25)

Equation (23) shows that to obtain the image moments, we need to calculate the moments of each block, so we turn to it in the following. Since Sn(x1,bi, x2,bi) and Sm (y1,bi, y2,bi) given in (25) can be calculated in a similar way, we consider only the computation of Sn (x1,bi, x2,bi).

Assuming that the block bi contains δbi = x2,bix1,bi + 1 pixels in width, we have

Sn(x1,bi,x2,bi)=j=0δbi1tn(x1,bi+j).
(26)

Using (22), we have

tn+1(x1,bi+j+1)tn+1(x1,bi+j)=k=0ng1(n+1,k)tk(x1,bi+j).
(27)

Summing the two sides of (27) from j = 0 to δbi − 1, we obtain

tn+1(x1,bi+δbi)tn+1(x1,bi)=j=0δbi1k=0ng1(n+1,k)tk(x1,bi+j)=k=0ng1(n+1,k)j=0δbi1tk(x1,bi+j).
(28)

Using (26) and making the notation

Rn(δbi)=tn+1(x1,bi+δbi)tn+1(x1,bi),
(29)

Equation (28) becomes

Rn(δbi)=k=0ng1(n+1,k)Sk(x1,bi,x2,bi).
(30)

Let Vm(x1,bi, x2,bi) = (S0(x1,bi, x2,bi), S1(x1,bi, x2,bi), … SM−1(x1,bi, x2,bi))T and UM(δbi) = (R0(δbi), R1(δbi),… RM−1(δbi))T where the subscript T denotes the transpose and M is the maximal order of Tchebichef moments we want to calculate, we have

UM(δbi)=AMVM(x1,bi,x2,bi),
(31)

where AM is an M × M lower triangular matrix given by

AM=[g1(1,0)000g1(2,0)g1(2,1)00g1(3,0)g1(3,1)g1(3,2)0g1(M,0)g1(M,1)g1(M,2)g1(M,M1)]
(32)

The elements g1(n, k) of the matrix AM can be computed via (19). In particular, we have

g1(n,n1)=2(2n1)ρ(n1,N)ρ(n,N)=2(2n1)(2n+1)(Nn)(N+n).
(33)

Since all the diagonal elements are not zero, the matrix AM is non-singular. Thus, we have

VM(x1,bi,x2,bi)=AM1UM(δbi).
(34)

The above equation shows that to obtain the values of VM(x1,bi, x2,bi), we need only to compute Um(δbi), which can be done via (29). The Tchebichef polynomial values can be calculated by the following recurrence formula [19]

tn(x)=α1tn(x1)+α2tn(x2),forn=1,2,3,,N1,x=2,3,,N/2,
(35)

where

α1=n(n+1)(2x1)(xN1)xx(Nx),α2=(x1)(xN1)x(Nx),
(36)

and

tn(0)=(Nn)(2n+1)(N+n)(2n1)tn1(0),tn(1)=[1+n(n+1)1N]tn(0),t0(0)=1N.
(37)

Note that in (35), the following symmetric property is used

tn(N1x)=(1)ntn(x).
(38)

As indicated by Mukundan [19], the use of (35) and (38) allows avoiding the numerical instability in the calculation of polynomial values.

Because the computation of g1(n, k) for 0 ≤ kn−2, when using (19), requires the evaluation of factorial functions, this could be time consuming. To avoid this, we use the following recurrence relations for computing the coefficients Bn, k, s.

Bn,0,0=2(Nn+1)n(2n1)(2n+1)(Nn)(N+n)Bn1,0,0,n2,
(39)
Bn,k,s=(ns+1)(n+ks+1)(nks)(Nn+s1)s(ns)(2ns+1)(Nn+s)Bn,k,s1,0snk1,
(40)
Bn,k,s=(nks)(n+ks)(2k+1)(N+k)(2k1)(Nk)Bn,k1,s,1kn2,
(41)
B1,0,0=23N21.
(42)

It is worth noting that the elements g1(n, k) are independent of the image f(x, y), they can thus be pre-computed and stored in a look-up table for further use.

C. Fast computation of Tchebichef moments for gray-scale images

By using the ISR algorithm, the Tchebichef moments of a gray-scale image f(x, y), which is described by (11), can be computed as

Tnm=x=0N1y=0N1tn(x)tm(y)i=1Lfi(x,y)=i=1Lx=0N1y=0N1tn(x)tm(y)fi(x,y)=i=1LfiTm(i),
(43)

where Tnm(i) is the (n+m)th order Tchebichef moments of the ith binary slice.

Equation (43) shows that the (n+m)th order Tchebichef moment of a gray-scale image f(x, y) is equal to the intensity-weighted sum of the same order Tchebichef moments of a number of binary slices. The latter moments can be computed using the algorithm presented in the previous subsection.

To summarize, the proposed method for computing the moment values is described as follows.

Algorithm for computing the Tchebichef moments

  • Step 1 Image block extraction using IBR algorithm for binary image and PIBR algorithm for gray-scale image.
  • Step 2 Computation of Tchebichef polynomial values at corners of each block using (35), and then the vector Rn(δbi) with (29).
  • Step 3 Calculation of 1-D Tchebichef moments of each block using (34).
  • Step 4 Computation of image moment values using (23) for binary image and (43) and (23) for gray-scale image.

V. Computational complexity and experimental results

In this section, we give a detailed analysis of computational complexity of the proposed algorithm, and provide some experimental results to validate the theoretic analysis.

A. Computational complexity

The complexity of the proposed algorithm is due to the extraction of the extraction of image blocks with the PIBR algorithm and to the computation of Tchebichef moments based on (23) for binary images or on (43) for gray-scale images. As pointed out by Papakostas et al. [28], the procedure of block extraction is performed by simple mathematical and logical operations, and it adds very short time overhead in the overall computation. For this reason, we do not take this part into account.

Since the computation of Tchebichef moments for a gray-scale image based on (43) depends on the algorithm being used to compute the moments of each slice, we first consider the arithmetic complexity of (23) using the proposed algorithm.

Let us consider the case where a binary image contains one rectangular block with level one. For simplicity and without loss of generality, assume a square block with J × J pixels, and the moments up to order (M−1, M−1) need to be calculated. For the direct method based on (1), the computation of Tchebichef polynomial values tn(x) using the recursive formula (35) for each given x requires 1 addition and 2 multiplications. The same number of arithmetic operations is needed for tm(y). Thus, the computation of Tchebichef moments Tnm of order up to (M−1, M−1) based on (1), using the direct method, for a block size J × J pixels needs M2(3J2−1) additions and 5M2J2 multiplications.

We then analyze the complexity of the proposed algorithm based on eqs (23) and (34). The computation of the vectors UM(δbi) and VM(x1,bi, x2,bi) requires respectively 3M additions and 4M multiplications, and M(M−1)/2 additions and M(M+1)/2 multiplications. Thus, the total arithmetic operations required in the computation of VM(x1,bi, x2,bi) are M2/2+5M/2 additions and M2/2+9M/2 multiplications. The same number of operations is required for VM(y1,bi, y2,bi). Therefore, the computation of M2 Tchebichef moments using (23) and (34) requires M2+5M additions and 2M2+9M multiplications. Table I summarizes these results. For comparison purpose, we also list in Table I the arithmetic complexity of the algorithms reported in Refs. [35], [37] and [38]. Note that the algorithm presented in [37] leads to the same number of arithmetic operations as in [36], and the method for computing the block moments reported in [38] is just based on (24), which requires (4J−2)M2 additions and (4J+1)M2 multiplications. It can be seen from this table that among these methods, both the proposed algorithm and the algorithm reported in [37] are independent of the block size, and our method has the lowest computational complexity.

TABLE I

Computational complexity of the direct method and proposed algorithm for computing the moments of order up to (M−1, M−1) of one block with J × J pixels

AdditionsMultiplications
Direct methodM2(3J2−1)5M2J2
Recursive method [35]M2(2J2+2J)M2(2J2+3J+1)
Method resented in [37]M3/3+M2+2M/3(M+1)(M+2)(M2+7M+24)/24
Papakostas’s method [38]M2(4J−2)M2(4J+1)
Proposed methodM2+5M2M2+9M

For a gray-scale image f(x, y) with size N × N, suppose that the total number of blocks for all the slices is NB, that is, NB=i=1LKi, where Ki is the number of blocks of the ith slice. Then the computation of Tchebichef moments Tnm of order up to (M−1, M−1) based on (1), using the direct method, requires M2(3N2−1) additions and 6M2N2 multiplications. The computational complexity of the algorithm reported in [38] is NB(4J−2)M2+L−1 additions and NB(4J+1)M2+L−1 multiplications, and that of the proposed algorithm based on (43) is NB(M2+5M)+L−1 additions and NB(2M2+9M)+L multiplications.

B. Experimental results

Some experimental results are provided in this subsection to validate the theoretical analysis. Since the algorithm presented in [37] was realized by hardware architecture, we compare here the proposed algorithm with the direct method, the recursive algorithm presented in [35] and the fast algorithm reported in [38] in terms of the computational efficiency. We do not provide a full comparison of our method with that reported in [39] for the following reasons: the main advantage of the technique presented by Bayraktar et al. [39] is its high precision. As noted by the authors, the computation of polynomial values using arbitrary precision calculator is much slower than the recurrence formula. So, their method is fast only if all the polynomial coefficients are pre-computed and stored in a look-up table. On the contrary, Bayraktar’s algorithm is less efficient than the previously reported fast algorithms.

In the first example, four binary images with size 256 × 256 pixels (Fig. 1) selected from the well-known MPEG-7 CE-shape-1 Part B database [40] were used as test images. The number of blocks of these images is NB = 171 for Apple, NB = 44 for Hammer, NB = 388 for Octopus and NB = 136 for Tree. Fig. 2 shows the average computation time of moments up to order (120, 120) for these four images using the direct method, the recursive algorithm based on Clenshaw’s recurrence formula, the algorithm reported in [38] and the proposed algorithm. Note that the algorithm was implemented in C++ on a PC Dual Core 2.33 GHz, 2GB RAM. Fig. 2 shows that the proposed algorithm is the fastest among all the methods, and the algorithm presented in [38] is more efficient than the other two methods. This is because these binary images have a small number of blocks. Note that the computation time for extracting the blocks of each image is about 1 ms, this time is much less than the computation time required in the calculation of moments.

An external file that holds a picture, illustration, etc.
Object name is halms503235f1.jpg

Set of test binary images with size 256 × 256 pixels.

An external file that holds a picture, illustration, etc.
Object name is halms503235f2.jpg

Average computation time for images shown in Fig. 1 using different methods

In the second example, four gray-scale images with size 256 × 256 pixels shown in Fig. 3 have been used. The number of blocks of these images is NB = 56211 for Lena, NB = 53048 for Pepper, NB = 47664 for Women and NB = 38561 for House. The computation time for extracting the blocks of each image is about 2 ms. Fig. 4 shows the average computation time up to order (120, 120) for these four images using various methods. The result again indicates that our method has better performance than the other algorithms. But the algorithm presented in [38] is only faster than the direct method due to the large number of blocks in these images, and the computation of 1-D moments based on (24) is time intensive. Fig. 5 shows the reconstructed results using the inverse transform (8).

An external file that holds a picture, illustration, etc.
Object name is halms503235f3.jpg

Set of test gray-scale images with size 256 × 256 pixels.

An external file that holds a picture, illustration, etc.
Object name is halms503235f4.jpg

Average computation time for images shown in Fig. 3 using different methods

An external file that holds a picture, illustration, etc.
Object name is halms503235f5.jpg

Reconstructed images of Fig. 3 using the inverse moment transform (8) with M = 120.

From the two previous experiments, it can be observed that our algorithm depends on the number of image blocks, which is related to the image content, rather than on the image size. To illustrate this, the images shown in Figs. 1 and and33 were scaled to different sizes (from 320 × 320 to 1024 × 1024) where the nearest interpolation was used. Using such an interpolation, the number of blocks does not change. Fig. 6 shows the average computation time required in the calculation of moments of order up to (40, 40) for different image sizes. It can be seen from this figure that both the proposed algorithm and Papakostas’s algorithm are much more efficient than the two other algorithms. To make a full comparison in terms of the efficiency of different methods, we also apply the bilinear interpolation to images shown in Figs. 1 and and3.3. In such a case, the number of blocks increases with the image size. The average computation time required in the calculation of moments of order up to (40, 40) for different image sizes is shown in Fig. 7. It can be observed from this figure that the computation time required in our method and Papakostas’s method increases compared to that of Fig. 6. However, the proposed method remains the most efficient one.

An external file that holds a picture, illustration, etc.
Object name is halms503235f6.jpg

Average computation time for images shown in Fig. 1 and Fig. 3 with varying sizes in the calculation of moments of order up to (40, 40) using nearest interpolation

An external file that holds a picture, illustration, etc.
Object name is halms503235f7.jpg

Average computation time for images shown in Fig. 1 and Fig. 3 with varying sizes in the calculation of moments of order up to (40, 40) using bilinear interpolation

VI. Conclusions

In this paper, by deriving some properties of Tchebichef polynomials, and using the image block representation and intensity slice representation, we have presented a fast algorithm for computing the Tchebichef moments for both binary and gray-scale images. The computation of the moments using the proposed method only depends on the number of blocks, thus, it can significantly decrease the computation time when the number of image blocks is much smaller than the image size.

Acknowledgments

The authors would like to thank the reviewers and Associate Editor Dr. Wu for their insightful suggestions which helped improve the quality of the manuscript.

This work was supported by the National Natural Science Foundation of China under Grants 60873048 and 60911130370, the National Basic Research Program of China under Grant 2010CB732503 and the Natural Science Foundation of Jiangsu Province of China under Grants SBK200910055 and BK2008279.

Appendix A

Proof of Theorem 1

By definition of dn, k, we have

(x)n=K=0Ndn,kPk(x).
(A1)

Using the following relationship [41]

(ax)l=s=0l(ls)(a)ls(x)s,
(A2)

where (ls)=l!s!(ls)! is the combination number, we have

Pn(a+x)=l=0ncn,l(ax)l=l=0ncn,ll=0n(ls)(a)ls(x)s=s=0nl=sncn,l(ls)(a)ls(x)s=s=0nl=0nscn,l+s(l+ss)(a)l(x)s=s=0nl=0nscn,l+s(l+ss)(a)lk=0sds,kPk(x)=k=0nl=0nks=knl(l+ss)cn,l+sds,k(a)lPk(x).
(A3)

The proof of Theorem 1 is completed.

Proof of Proposition 1

To prove the proposition, we need to demonstrate the following relation

k=mncn,kdk,m=δnm.
(A4)

where δnm is the Kronecker symbol.

Using (6) and (14), we have

k=mncn,kdk,m=(1)n(2m+1)(Nm1)!(Nn1)!ρ(m,N)ρ(n,N)k=mn(1)k(n+k)!(nk)!(k+m+1)!(km)!.
(A5)

For n = m, it can be easily deduced from (A5) that

cn,ndn,n=(1)n(2n+1)×(1)n(2n)!(2n+1)!=1.
(A6)

To prove (A4) for m < n, letting

G(n,k)=(1)k+1(n+k+1nk+1)(2kkm)(n+1k)(km)(n+k+1)(n+m+1)(nm).
(A7)

It can be verified that

G(n,k+1)G(n,k)=(1)k(n+k)!(nk)!(k+m+1)!(km)!.
(A8)

Substitution of (A8) into (A5), we obtain

k=mncn,kdk,m=(1)n(2m+1)(Nm1)!(Nn1)!ρ(m,N)ρ(n,N)k=mn(1)k(n+k)!(nk)!(k+m+1)!(km)!form<n.=(1)n(2m+1)(Nm1)!(Nn1)!ρ(m,N)ρ(n,N)k=mn[G(n,k+1)G(n,k)]=(1)n(2m+1)(Nm1)!(Nn1)!ρ(m,N)ρ(n,N)[G(n,n+1)G(n,m)]=0,
(A9)

The proof is now complete.

Note that the proof of Proposition was inspired by a technique proposed by Petkovsek et al. [42].

Proof of Theorem 2

It can be easily verified from (21) that g0(n, n) = 1. To prove g0(n, k) = 0 for kn−1, it suffices to apply the relationship (A9) to (18).

References

1. Dudani SA, Breeding KJ, McGhee RB. Aircraft identification by moment invariant. IEEE Trans Comput. 1977;26(1):39–46. [Google Scholar]
2. Khotanzad A. Invariant image recognition by Zernike moments. IEEE Trans Pattern Anal Mach Intell. 1990;12(5):489–497. [Google Scholar]
3. Belkasim SO. Pattern recognition with moment invariants—A comparative study and new results. Pattern Recognit. 1991;24(12):1117–1138. [Google Scholar]
4. Pei S, Lin C. Normalization of rotationally symmetric shapes for pattern recognition. Pattern Recognit. 1992;25(9):913–920. [Google Scholar]
5. Flusser J. Pattern recognition by affine moment invariants. Pattern Recognit. 1993;26(1):167–174. [Google Scholar]
6. Hu MK. Visual pattern recognition by moment invariants. IRE Trans Inform Theory. 1962;IT-8(2):179–187. [Google Scholar]
7. Prokop RJ, Reeves AP. A survey of moment based techniques for unoccluded object representation. Graph Models Image Process. 1992;54(5):438–462. [Google Scholar]
8. Mukundan R, Ramakrishnan KR. Moment Functions in Image Analysis – Theory and Applications. Singapore: World Scientific; 1998. [Google Scholar]
9. Shu HZ, Luo LM, Coatrieux JL. Moment-based approaches in image Part 1: basic features. IEEE Eng Med Biol Mag. 2007;26(5):70–74. [Europe PMC free article] [Abstract] [Google Scholar]
10. Shu HZ, Luo LM, Coatrieux JL. Moment-based approaches in image Part 2: invariance. IEEE Eng Med Biol Mag. 2008;27(1):81–83. [Europe PMC free article] [Abstract] [Google Scholar]
11. Shu HZ, Luo LM, Coatrieux JL. Moment-based approaches in image Part 3: computational considerations. IEEE Eng Med Biol Mag. 2008;27(3):89–91. [Europe PMC free article] [Abstract] [Google Scholar]
12. Shu HZ, Luo LM, Coatrieux JL. Moment-based approaches in imaging Part 4: some applications. IEEE Eng Med Biol Mag. 2008;27(5):116–118. [Europe PMC free article] [Abstract] [Google Scholar]
13. Teague MR. Image analysis via the general theory of moments. J Opt Soc Amer. 1980;70:920–930. [Google Scholar]
14. Teh CH, Chin RT. On image analysis by the method of moments. IEEE Trans Pattern Anal Mach Intell. 1988;10(4):496–513. [Google Scholar]
15. Liao SX, Pawlak M. On image analysis by moments. IEEE Trans Pattern Anal Mach Intell. 1996;18(3):254–266. [Google Scholar]
16. Ping ZL, Wu RG, Sheng YL. Image description with Chebyshev-Fourier moments. J Opt Soc Am A. 2002;19(9):1748–1754. [Abstract] [Google Scholar]
17. Xia T, Zhu HQ, Shu HZ, Haigron P, Luo LM. Image description with generalized pseudo-Zernike moments. J Opt Soc Am A. 2007;24(1):50–59. [Europe PMC free article] [Abstract] [Google Scholar]
18. Mukundan R, Ong SH, Lee PA. Image analysis by Tchebichef moments. IEEE Trans Image Process. 2001;10(9):1357–1364. [Abstract] [Google Scholar]
19. Mukundan R. Some computational aspects of discrete orthonormal moments. IEEE Trans Image Process. 2004;13(8):1055–1059. [Abstract] [Google Scholar]
20. Yap PT, Raveendran P, Ong SH. Image analysis by Krawtchouk moments. IEEE Trans Image Processing. 2003;12(11):1367–1377. [Abstract] [Google Scholar]
21. Zhu HQ, Shu HZ, Liang J, Luo LM, Coatrieux JL. Image analysis by discrete orthogonal dual-Hahn moments. Pattern Recognit Lett. 2007;28:1688–1704. [Google Scholar]
22. Zhu HQ, Shu HZ, Liang J, Luo LM, Coatrieux JL. Image analysis by discrete orthogonal Racah moments. Signal Process. 2007;87:687–708. [Google Scholar]
23. Yap PT, Raveendran P, Ong SH. Image analysis using Hahn moments. IEEE Trans Pattern Anal Mach Intell. 2007;29(11):2057–2062. [Abstract] [Google Scholar]
24. Yang L, Albregtsen F. Fast and exact computation of Cartesian geometric moments using discrete Green’s theorem. Pattern Recognit. 1996;29(7):1069–1073. [Google Scholar]
25. Spiliotis IM, Mertzios BG. Real-time computation of two-dimensional moments on binary images using image block representation. IEEE Trans Image Process. 1998;7(11):1609–1615. [Abstract] [Google Scholar]
26. Flusser J. Refined moment calculation using image block representation. IEEE Trans Image Process. 2000;9(11):1977–1978. [Abstract] [Google Scholar]
27. Chung KL, Chen PC. An efficient algorithm for computing moments on a block representation of a grey-level image. Pattern Recognit. 2005;38(12):2578–2586. [Google Scholar]
28. Papakostas GA, Karakasis EG, Koulourisotis DE. Efficient and accurate computation of geometric moments on gray-scale images. Pattern Recognit. 2008;41(6):1895–1904. [Google Scholar]
29. Mukundan R, Ramakrishnan KR. Fast computation of Legendre and Zernike moments. Pattern Recognit. 1995;28(9):1433–1442. [Google Scholar]
30. Shu HZ, Luo LM, Yu WX, Fu Y. A new fast method for computing Legendre moments. Pattern Recognit. 2000;33(2):341–348. [Google Scholar]
31. Yap PT, Raveendran P. An efficient method for the computation of Legendre moments. IEEE Trans Pattern Anal Machine Intell. 2005;27(12):1996–2002. [Abstract] [Google Scholar]
32. Yang GY, Shu HZ, Toumoulin C, Han GN, Luo LM. Efficient Legendre moment computation for grey level images. Pattern Recognit. 2006;39(1):74–80. [Google Scholar]
33. Gu J, Shu HZ, Toumoulin C, Luo LM. A novel algorithm for fast computation of Zernike moments. Pattern Recognit. 2002;35(12):2905–2911. [Google Scholar]
34. Chong CW, Raveendran P, Mukundan R. A comparative analysis of algorithms for fast computation of Zernike moments. Pattern Recognit. 2003;36(3):1765–1773. [Google Scholar]
35. Wang GB, Wang SG. Recursive computation of Tchebichef moment and its inverse transform. Pattern Recognit. 2006;39(1):47–56. [Google Scholar]
36. Kotoulas L, Andreadis I. Fast computation of Chebyshev moments. IEEE Trans Circuits Syst Video Technol. 2006;16(7):884–888. [Google Scholar]
37. Kotoulas L, Andreadis I. Fast moment generating architectures. IEEE Trans Circuits Syst Video Technol. 2008;18(4):533–537. [Google Scholar]
38. Papakostas GA, Karakasis EG, Koulourisotis DE. A unified methodology for efficient computation of discrete orthogonal image moments. Information Sciences. 2009;179(20):3619–3633. [Google Scholar]
39. Bayraktar B, Bernas T, Robinson JP, Rajwa B. A numerical recipe for accurate image reconstruction from discrete orthogonal moments. Pattern Recognit. 2007;40(2):659–669. [Google Scholar]
41. Comet L. Advanced combinatorics: The art of finite and infinite expansions. Dordrecht: Holland, D. Reidel Publishing Company; 1974. [Google Scholar]
42. Petkovsek M, Wilf HS, Zeilberger D. A = B. AK Peters, Ltd; 1996. (Available on line at the University of Pennsylvania) [Google Scholar]

Citations & impact 


Impact metrics

Jump to Citations

Citations of article over time

Smart citations by scite.ai
Smart citations by scite.ai include citation statements extracted from the full text of the citing article. The number of the statements may be higher than the number of citations provided by EuropePMC if one paper cites another multiple times or lower if scite has not yet processed some of the citing articles.
Explore citation contexts and check if this article has been supported or disputed.
https://scite.ai/reports/10.1109/tip.2010.2052276

Supporting
Mentioning
Contrasting
0
10
0

Article citations