FORM 2
THE PATENTS ACT, 1970
(39 of 1970)
&
THE PATENTS RULES, 2003
COMPLETE SPECIFICATION
(See section 10, rule 13)
1. Title of the invention: IMAGE PROCESSING USING MULTI-BASE NUMBER SYSTEM
(MBNS)
2. Applicant(s)
NAME NATIONALITY ADDRESS
TATA CONSULTANCY Indian Nirmal Building, 9th Floor, Nariman
SERVICES LIMITED Point, Mumbai 400021,
Maharashtra
India
3. Preamble to the description
COMPLETE SPECIFICATION
The following specification particularly describes the invention and the manner in which it
is to be performed.

TECHNICAL FIELD
[001] The present subject matter described herein, in general, relates to image
processing using Multi-based number system.
BACKGROUND
[002] Digital Signal Processing (DSP) may be computationally complex as it
requires processing a large amount of data. Typically, processors are configured to process this data, such as numerical data, in the form of bits. Numerical data is generally represented using various number systems. The number systems provide a unique representation to every number and an algebraic structure for the numbers. Traditional Single-Base Number Systems (SBNS), such as binary, octal, decimal, and hexadecimal systems, include one base only, for example, the base is 2 for binary numbers, 8 for octal numbers, 10 for decimal numbers, and 16 for hexadecimal numbers.
[003] In recent years, Multi-Base Number System (MBNS) have been introduced for
various DSP applications. The MBNS may include Double-Base Number System (DBNS), Triple-Base Number System (TBNS), and so on. The MBNS may use at least two bases to represent a number. Generally, first few prime numbers (2, 3, 5, 7….and so on) are chosen as the bases for the MBNS. A typical MBNS representation with two bases for integer 127 can be 2233 + 2132 + 2030 or 2233 + 2430 + 2031 or 2531 + 2033 + 2230. Similarly, a typical MBNS representation with three bases for the integer 127 can be 203053 + 213050 or 223350 + 213250 + 203050.
[004] Clearly, these representations involve high redundancy as one integer can have
multiple MBNS representations. The MBNS representations with the minimum summands or number of sets of n-integers (2a3b5c...nx) are called optimum MBNS representations as they consume fewer bits. Finding the optimum MBNS representation from various possible MBNS representations may be a time and resource consuming process, for example, integer 127 can have multiple TBNS representations, among which only one is optimum representation, i.e., 203053 + 213050 having only two summands with 3 integers each.

[005] As known, many theoretical approaches based on MBNS have been proposed
for DSP. One of such approaches involves using lookup tables with a specific addressing scheme. In real-time applications, such as DSP and security applications, such lookup tables based solutions become unrealistic to implement because the real-time applications generally involve large numbers and complex calculations.
SUMMARY
[006] This summary is provided to introduce concepts related to systems and
methods for image processing using Multi-Base Number System (MBNS), and the concepts are further described below in the detailed description. This summary is not intended to identify essential features of the claimed subject matter nor is it intended for use in determining or limiting the scope of the claimed subject matter.
[007] In one implementation, a method for image processing using Multi-Base
Number System (MBNS) is disclosed. The method comprises receiving an image in a form of a pixel matrix. The method further comprises segregating the pixel matrix into a set of even pixels and into a set of odd pixels. The method further comprises dividing the set of even pixels into a plurality of subsets of even pixels; and the set of odd pixels into a plurality of subsets of odd pixels. The method further comprises determining MBNS forms simultaneously for each pixel in the plurality of subsets of even pixels and in the plurality of subsets of odd pixels. The method further comprises computing Discrete Fourier Transform (DFT) of the image using the MBNS forms of the pixels.

BRIEF DESCRIPTION OF THE DRAWINGS
[008] The detailed description is described with reference to the accompanying
figures. In the figures, the left-most digit(s) of a reference number identifies the figure in which the reference number first appears. The same numbers are used throughout the drawings to reference like features and components.
[009] Figure 1 shows a network implementation of an image processing system, in
accordance with an embodiment of the present disclosure.
[0010] Figure 2 shows a flowchart illustrating a method for image processing using a
Multi-Base Number System (MBNS), in accordance with an embodiment of the present subject matter.
DETAILED DESCRIPTION
[0011] Systems and methods for image processing using a Multi-Base Number
System (MBNS) are described herein. The MBNS has proved to be efficient in applications involving large numbers and complex calculations, such as data compression, data security, applications of digital signal processing (DSP), and the like. The MBNS is efficient because of the fact that an MBNS representation generally utilizes fewer bits as compared to a Single-Base Number System (SBNS) representation of a number and is computed faster as well. It may be understood that the MBNS may include Double-Base Number System (DBNS), Triple-Base Number System (TBNS), and so on.
[0012] The MBNS has proved to be efficient in executing arithmetic operations, such
as addition, subtraction, and multiplication. Efficiency in executing the arithmetic operations allows the MBNS to be useful for effectively solving mathematical problems, particularly in real-time applications including DSP applications. The DSP applications may include image processing, speech processing, and the like. In order to process an image digitally, at first, an image, in the form of a pixel matrix, may be received by the system. Conventionally, the image is processed by dividing the pixel matrix in two halves and then processing each half of the pixel matrix in SBNS. This conventional method of image processing consumes a lot of time and is computationally expensive.

[0013] However, in the present subject matter, the pixel matrix representing the image
is segregated into a set of even pixels and a set of odd pixels. For example, consider that the image contains 100,000 pixels arranged in the pixel matrix. In the pixel matrix, half of the 100,000 pixels will be placed on odd numbered positions and the remaining half will be placed on even numbered positions. The pixels present at the odd numbered positions in the pixel matrix may be referred to as odd pixels and the pixels present at the even numbered positions in the pixel matrix may be referred to as even pixels. Therefore, two sets of pixels, i.e., the set of even pixels and the set of odd pixels may be segregated in the pixel matrix.
[0014] Subsequently, the set of even pixels may be divided into a plurality of subsets
of even pixels; and the set of odd pixels may be divided into a plurality of subsets of odd pixels. Considering the above example again, the set of odd pixels comprising 50,000 pixels may further be divided into a plurality of subsets of odd pixels, i.e., a first subset of odd pixels containing 15,000 pixels, a second subset of odd pixels containing 20,000 pixels, and a third subset of odd pixels containing 15,000 pixels. Similarly, the set of even pixels containing 50,000 pixels may also be further divided into a plurality of subsets of even pixels, i.e., a first subset of even pixels containing 15,000 pixels, a second subset of even pixels containing 20,000 pixels, and a third subset of even pixels containing 15,000 pixels.
[0015] After the set of even pixels is divided into the plurality of subsets of even
pixels; and the set of odd pixels is divided into the plurality of subsets of odd pixels, MBNS forms may be determined simultaneously for each pixel present in the plurality of subsets of even pixels and in the plurality of subsets of odd pixels. The MBNS forms may be determined using one or methods explained below. The MBNS forms include MBNS summands which may be used for computing Discrete Fourier Transform (DFT) and for further processing of the image.
[0016] By creating the plurality of subsets of odd pixels and the plurality of subsets of
even pixels and then simultaneously determining MBNS forms, the computational complexity is reduced and image processing becomes faster as compared to conventional image processing techniques. Further, the MBNS forms occupy less space in the memory. Furthermore, the MBNS forms have an inherent property of dot product that comes from the product of powers of 2, 3, 5, and so on. While using MBNS forms in image/signal processing,

the system yields efficient results with respect to auto-correlation. Moreover, the dot product helps to normalize the image or signal due to lighting and exposure conditions. Further, using MBNS forms help to reduce repeated patterns, such as periodic signals buried under noise. This is due to less number of repeated summands or, in some cases, no repeated summands of MBNS. The MBNS representation is not unique and behaves in a pseudo-random manner so that it helps the images in reducing spike noise and/or salt and pepper noise.
[0017] While aspects of described system and method for image processing using
MBNS may be implemented in any number of different computing systems, environments, and/or configurations, the embodiments are described in the context of the following exemplary system.
[0018] Referring now to Figure 1, a network implementation 100 of an image
processing system 102 for processing an image using a Multi-Base Number System (MBNS) is illustrated, in accordance with an embodiment of the present subject matter. The image processing system 102 may be implemented in a variety of computing systems, such as a laptop computer, a desktop computer, a notebook, a workstation, a mainframe computer, a digital camera, a server, a network server, and the like. It will be understood that the image processing system 102 may be accessed by users through one or more client devices 104-1, 104-2,…104-N, collectively referred to as client devices 104 hereinafter, or applications residing on client devices 104. Examples of the client devices 104 may include, but are not limited to, a portable computer, a personal digital assistant, a handheld device, and a workstation. The client devices 104 are communicatively coupled to the image processing system 102 through a network 106.
[0019] In one implementation, the network 106 may be a wireless network, a wired
network or a combination thereof. The network 106 can be implemented as one of the different types of networks, such as intranet, local area network (LAN), wide area network (WAN), the internet, and the like. The network 106 may either be a dedicated network or a shared network. The shared network represents an association of the different types of networks that use a variety of protocols, for example, Hypertext Transfer Protocol (HTTP), Transmission Control Protocol/Internet Protocol (TCP/IP), Wireless Application Protocol (WAP), and the like, to communicate with one another. Further the network 106 may include

a variety of network devices, including routers, bridges, servers, computing devices, storage devices, and the like.
[0020] In one embodiment, the image processing system 102 may include at least one
processor 108, an I/O interface 110, and a memory 112. The at least one processor 108 may be implemented as one or more microprocessors, microcomputers, microcontrollers, digital signal processors, central processing units, state machines, logic circuitries, and/or any devices that manipulate signals based on operational instructions. Among other capabilities, the at least one processor 108 is configured to fetch and execute computer-readable instructions stored in the memory 112.
[0021] The I/O interface 110 may include a variety of software and hardware
interfaces, for example, a web interface, a graphical user interface, and the like. The I/O interface 110 may allow the image processing system 102 to interact with a user directly or through the client devices 104. Further, the I/O interface 110 may enable the image processing system 102 to communicate with other computing devices, such as web servers and external data servers (not shown). The I/O interface 110 can facilitate multiple communications within a wide variety of networks and protocol types, including wired networks, for example, LAN, cable, etc., and wireless networks, such as WLAN, cellular, or satellite. The I/O interface 110 may include one or more ports for connecting a number of devices to one another or to another server.
[0022] The memory 112 may include any computer-readable medium known in the art
including, for example, volatile memory, such as static random access memory (SRAM) and dynamic random access memory (DRAM), and/or non-volatile memory, such as read only memory (ROM), erasable programmable ROM, flash memories, hard disks, optical disks, and magnetic tapes. The memory 112 may include modules 114 and data 116.
[0023] The modules 114 include routines, programs, objects, components, data
structures, etc., which perform particular tasks or implement particular abstract data types. In one implementation, the modules 114 may include a central module 118, a computational module 120, and other modules 122. The other modules 122 may include programs or coded instructions that supplement applications and functions of the image processing system 102.

[0024] The data 116, amongst other things, serves as a repository for storing data
processed, received, and generated by one or more of the modules 114. The data 116 may also include an image database 124, and other data 126. The other data 126 may include data generated as a result of the execution of one or more modules in the other module 122.
[0025] In one implementation, a user may wish to digitally process an image. In order
to process the image, the user may send the image to the image processing system 102 using the client device 104. In another implementation, the image may be pre-stored in the image processing system 102. The I/O interface 110 of the image processing system 102 may receive the image from the client device 104 and save the image in the image database 124. As known, the image may be in a form of a pixel matrix. Although in the present implementation, the image is received from the client devices 104, in another implementation, the image may be pre-stored in the image database 124.
[0026] The image stored in the image database 124 may be accessed by the central
module 118. The central module 118 may segregate the image, i.e., the pixel matrix into a set of even pixels and set of odd pixels. In one example, consider that the pixel matrix contains 100,000 pixels. In the pixel matrix, half of the 100,000 pixels will be placed on odd numbered positions in the pixel matrix and the remaining half will be placed on even numbered positions in the pixel matrix. The pixels present at the odd numbered positions in the pixel matrix may be referred to as odd pixels and the pixels present at the even numbered positions in the pixel matrix may be referred to as even pixels. In the present implementation, the central module 118 may run an algorithm to extract out odd pixels from the pixel matrix and create the set of odd pixels. The pixels remaining in the pixel matrix are even pixels, thereby giving rise to the set of even pixels. Therefore, each of the two sets of pixels, i.e., the set of even pixels and the set of odd pixels may comprise 50,000 pixels each. The advantage of segregating the pixels into even and odd would be reduced computational complexity on the pixels. This segregation process saves at least 50% on operations of pixels. For instance, in the present example, an image processing operation will be performed on the two sets of 50,000 pixels in parallel thereby saving computations.
[0027] Subsequent to the segregation of the pixel matrix, the central module 118 may
divide the set of even pixels into a plurality of subsets of even pixels. In one implementation,

in order to do so, the central module 118 may run an algorithm to divide the set of even pixels equally or unequally based upon a set of rules. Similarly, the central module 118 may also divide the set of odd pixels into a plurality of subsets of odd pixels. In one implementation, in order to do so, the central module 118 may run an algorithm to divide the set of odd pixels equally or unequally based upon the set of rules.
[0028] Considering the above example, the set of odd pixels containing 50,000 pixels
may further be divided into the plurality of subsets of odd pixels, i.e., a first subset of odd pixels containing 15,000 pixels, a second subset of odd pixels containing 20,000 pixels, and a third subset of odd pixels containing 15,000 pixels. Similarly, the set of even pixels containing 50,000 pixels may also be further divided into a plurality of subsets of even pixels, i.e., a first subset of even pixels containing 15,000 pixels, a second subset of even pixels containing 20,000 pixels, and a third subset of even pixels containing 15,000 pixels.
[0029] After the set of even pixels is divided into the plurality of subsets of even
pixels; and the set of odd pixels is divided into the plurality of subsets of odd pixels, the computational module 120 may simultaneously determine MBNS forms for each pixel present in the plurality of subsets of even pixels and in the plurality of subsets of odd pixels. In one implementation, the MBNS form is determined based upon an amplitude/brightness of each pixel in the image. The amplitude of a pixel depicts a value of that pixel and may be an integer. It may be understood that in one implementation, the MBNS forms may be determined for several pixels together in a group. For example, if a value of a pixel X is 117 and all the neighbors of pixel X also have the same value, then MBNS representation may be determined for pixel X and the same representation may be used for rest of the neighbors of the pixel X.
[0030] As mentioned above, the value of a pixel may be an integer and this integer is
an ‘n-integer’ if all of its prime divisors are among the first n prime numbers, such as 2, 3, 5,..., and so on. The n-integer is represented as 2a3b5c….nx and is a single summand of a typical MBNS representation having multiple summands as shown below:
2a13b15c1…nx1 + 2a23b25c2 ...nx + ………………….2an3bn5cn….nxn

[0031] The computational module 120 uses the amplitude of each pixel to determine
an MBNS representation of each pixel in the form ∑2a3b5c…nx, i.e., as a sum of one or more n-integers of the form 2a3b5c…nx. In the process of determining the MBNS form, at first, the computational module 120 computes the first n-integer, which is largest of n-integers less than or equal to the amplitude of the pixel.
[0032] Let us consider that in implementation, three bases i.e., 2, 3, and 5 are used for
computing MBNS forms of the amplitude of the pixels. If the MBNS uses three bases and if, in one example, the amplitude of a pixel is 85 and is received as input data by the computational module 120, then the first 3-integer which is largest of n-integers less than or equal to 85 can be 203450, i.e., 81. In one implementation, the computational module 120 stores the first n-integer in the image database 124.
[0033] Since the first n-integer serves as a first n-integer of the MBNS representation,
therefore, keeping the first n-integer less than or equal to the input data helps in decreasing the memory consumption in small processors. Further, in processors, such as a 64 bit processor, computing the first 3-integer less than the input data will consume less memory as compared to memory consumed by the first n-integer greater than the input data. For example, a 63-bit integer n = 9223372036854775806 may be expressed as a difference of a 64-bit number (9223372036854775808) and 2, i.e., 9223372036854775808 - 2 = 263 -2. Computing such a representation that exceeds 64 bit computation requires the use of a multi-precision integer arithmetic (MIA) library. However, using the MIA library for computations consumes more memory and power, which may not suitable for tiny hardware processors, such as processors used in hearing aids. Thus, the first n-integer is always computed as a largest n-integer less than or equal to the input data.
[0034] After computing the first n-integer, the computational module 120 is
configured to store values of exponents (a1, b1, c1…x1) corresponding to the first n-integer in the image database 124. For example, if the computational module 120 computes the first 3-integer as 203450, i.e., 81, then the exponents {040} are stored in the image database 124.
[0035] Upon computation of the first n-integer, the computational module 120
ascertains a first difference between the input data and the first n-integer. In one implementation, the computational module 120 subtracts the first n-integer from the input

data in order to obtain the first difference. For example, the computational module 120 ascertains a first difference between the input data, say 85, and the first 3-integer 203450, i.e., 81 as 4. In one implementation, the computational module 120 stores the first difference in the image database 124.
[0036] When the first difference is non-zero, then the computational module 120
determines a maximum value for an exponent of each base of the next n-integer of the MBNS representation. In one implementation, computational module 120 stores the maximum value in the image database 124. Further, the maximum value is defined by a minimum of a stored exponent of corresponding base of the previous n-integer and one plus floor of log of the first difference in the corresponding base. For example, the maximum values for exponents of the next 3-integer are defined as:
Maximum value of a(n) = min {(a(n-1), 1 + Floor [Log2 (first difference)]}
Maximum value of b(n) = min {(b(n-1), 1 + Floor [Log3 (first difference)]}
Maximum value of c(n) = min {(c(n-1), 1 + Floor [Log5 (first difference)]}
[0037] Here, a(n), b (n), and c(n) are exponents of base 2, base 3, and base 5
respectively of the next 3-integer. In the above mentioned example, the maximum values of exponents corresponding to the next 3-integer are defined by the stored values {040} and the first difference of 4 as indicated below:
Maximum value of a(n) = min {0, 1 + Floor [Log24]} = min {0, 3} = 0
Maximum value of b(n) = min {4, 1 + Floor [Log34]} = min {4, 2} = 2
Maximum value of c(n) = min {0, 1 + Floor [Log54]} = min {0, 1} = 0
[0038] When the first difference is non-zero, then the computational module 120
computes the next n-integer nearest to the first difference with exponents in a range of zero to the maximum value of the corresponding base. In the above mentioned example, the next 3-integer nearest to the first difference of 4 is 203150, i.e., 3 with exponents in range of 0 to 0, 0 to 2, and 0 to 0. In one implementation, computational module 120 stores the next n-integer and the exponent of each base of the next 3-integer in the image database 124. In the above mentioned example, exponents {010} of the next 3-integer 203150 nearest to the first

difference of 4 are stored in the image database 124. In one implementation, the computational module 120 may compute the next n-integer based on predefined computation rules such as, computing n-integers which are non-repeating, i.e., a set of already stored exponents is not repeated in the MBNS representation of the input data.
[0039] Further, the computational module 120 ascertains the next difference between
the first difference and the next n-integer. In the above mentioned example, the next difference between the first difference 4 and the next 3-integer 203150, i.e., 3, is 1. In one implementation, the computational module 120 stores the next difference in the image database 124. When the next difference is non-zero, the next difference can be taken as the first difference for computing the next 3-integer. The cycle is repeated with the next difference taken as the first difference. In the above mentioned example, 1 is assigned as the first difference to create a loop that keeps on computing the next-n integers till the next difference becomes zero. In this way, the MBNS representation with decreasing order of exponents for input data 85 may be represented as 203450 + 203150 + 203050, i.e., 81+3+1.
[0040] After determining MBNS forms for each pixel in the image, the computational
module 120 may compute Discrete Fourier Transform (DFT) of the image using the MBNS forms of the pixels. In one example, the DFT of ym = ∑xk wnmk where n = 2r and k, m = 1, 2,..., 2r -1. Given that ‘n’ is converted into a special DBNS form having all summands into even numbers of the form 2a3b except one. Given that the integer ‘n’ is in DBNS representation, the summands in the representation become small compared to binary method. Further, each summand can be split into even and odd terms for executing image pixels. Expressing each summand in the even number of the form 2a3b (except one) helps to divide even and odd terms equally. Then each summand of the special DBNS form is passed into a divide and conquer system (not shown) for computing DFT/FFT. The special DBNS form helps to reduce the size of ‘n’ and also reduce the cost of computation of FFT. Further, by using DBNS in FFT, there are (log n)/(log log n) recursions, each of which involves Ω(n) arithmetic operations so that total cost is O (n log n) / (log log n).
[0041] In one implementation, in order to compute FFT using DBNS, the following
example may be considered:
Input (x, y, n, w)

To compute fft (x, y, n, w)
DBNS form: n = ∑finite 2x 3y = ∑ si
(where each si is even except sm, i = 1, 2, ..., m)
procedure fft(x, y, si, w)
if si = 1 then
y[0] = x[0]
else
for k = 0 to (si/2) - 1
p[k] = x[2k]
s[k] = x[2k + 1]
end
fft(p, q, si /2, w2)
fft(s, t, si /2, w2)
for k = 0 to si - 1
y[k] = q[k mod (n/2)] + wkt [k mod (n/2)]
end
end
[0042] For a given integer ‘n’, DFT of n-point sequence may be determined. Before
the DFT of n-point sequence is determined, a DBNS representation of the integer ‘n’ may be determined. The DBNS representation of ‘n’ is then divided into two halves, such as even summands and odd summands. Subsequently, each of the DBNS summands is processed using the Divide and Conquer method in order to determine DFT of ‘n’, thus reducing computational complexity drastically.

[0043] It may be understood that DBNS / MBNS representation allows any DFT to be
converted into a product of two entities A and B, where A = the sum of DFT data vectors and
B = the sum of primitive cube root of unity containing DBNS / MBNS representations. The
DFT may also be converted to convolution when the transform length N is a prime power, i.e.,
N is prime (pr) and 2. The conversion is a bit more complicated since integers which
contain a factor p from the set {1, 2, ..., N-1}are first removed to get a cyclic group with pr-
1(p-1) elements. This cyclic group leads to a circular convolution of length pr-1(p-1). So, the
length N transform is computed with 1 length pr-1(p-1) convolutions, 2 length pr-2(p-1)
convolutions, 4 length pr-3(p-1) convolutions, terminating with 2r-1 length p-1 convolutions.
[0044] Given a transform length N (> 2) need not be a prime power. Then N is
expressed as the sum of product of primes pi, where each pi > 2. Using DBNS representations, N may be expressed as a sum of product of powers of p1 and p2 (N = ∑ finite(p1)i (p2)j ) where p1 and p2 are primes > 2. Similarly N = ∑ finite(p1)i (p2)j (p3)k holds while using MBNS representations ( p1, p2 and p3 are primes > 2). Therefore, the length N transform is computed 1 length ∑ finite Φ((p1)i) Φ((p2)j ) convolutions, where Φ is Euler's Phi. Therefore, given a transform length N of DFT can be expressed as ∑ finite(p1)i (p2)j (where p1 and p2 are primes > 2 and N> 2). Then the length N transform is computed as follows:
1 length ∑ finite Φ((p1)i) Φ((p2)j ) = ∑ finite{(p1)i-1 ( p1 -1)}{(p2)j-1 ( p2 -1)} convolutions
2 length ∑ finite{(p1)i-2 ( p1 -1)}{(p2)j-2( p2 -1)} convolutions and so on (where Φ is Euler's Phi).
[0045] Similarly, the computational module 120 may also calculate Inverse Fourier
Transform of the image using methods known in the art. Therefore, it may be understood that the image processing system 102 may be used for processing the image using a Multi-Base Number System (MBNS). The image processing may include image compression, transmission, enhancement, and the like. The MBNS forms have an inherent property of dot product that comes from the product of powers of 2, 3, 5, and so on. While using MBNS forms in image/signal processing, the image processing system 102 yields efficient results with respect to auto-correlation. Further, the dot product helps to normalize the image or signal due to lighting and exposure conditions.

[0046] Referring now to Figure 2, a method 200 for image processing using a Multi-
Base Number System (MBNS) is shown, in accordance with an embodiment of the present subject matter. The method 200 may be described in the general context of computer executable instructions. Generally, computer executable instructions can include routines, programs, objects, components, data structures, procedures, modules, functions, etc., that perform particular functions or implement particular abstract data types. The method 200 may also be practiced in a distributed computing environment where functions are performed by remote processing devices that are linked through a communications network. In a distributed computing environment, computer executable instructions may be located in both local and remote computer storage media, including memory storage devices.
[0047] The order in which the method 200 is described is not intended to be construed
as a limitation, and any number of the described method blocks can be combined in any order to implement the method 200 or alternate methods. Additionally, individual blocks may be deleted from the method 200 without departing from the spirit and scope of the subject matter described herein. Furthermore, the method can be implemented in any suitable hardware, software, firmware, or combination thereof. However, for ease of explanation, in the embodiments described below, the method 200 may be considered to be implemented in the above described system 102.
[0048] At block 202, an image in the form of a pixel matrix may be received. In one
example, the image may be received by the central module 118.
[0049] At block 204, the pixel matrix is segregated into a set of even pixels and a set
of odd pixels. In one example, the image may be segregated by the central module 118.
[0050] At block 206, the set of even pixels may be divided into a plurality of subsets
of even pixels; and the set of odd pixels may be divided into a plurality of subsets of odd pixels. In one example, the set of even pixels and the set of odd pixels are divided by the central module 118.
[0051] At block 208, MBNS forms may be determined simultaneously for each pixel
in the plurality of subsets of even pixels and in the plurality of subsets of odd pixels. In one example, the MBNS forms may be determined by the computational module 120.

[0052] At block 210, Discrete Fourier Transform (DFT) of the image may be
computed using the MBNS forms of the pixels. In one example, the DFT is computed by the computational module 120.
[0053] Although implementations for methods and systems for image processing
using a Multi-Base Number System (MBNS) have been described in language specific to structural features and/or methods, it is to be understood that the appended claims are not necessarily limited to the specific features or methods described. Rather, the specific features and methods are disclosed as examples of implementations such system.

I/we claim:
1. A computer implemented method for image processing using a multi-based number
system (MBNS), the computer implemented method comprising:
receiving an image, wherein the image is in a form of a pixel matrix; segregating the pixel matrix into a set of even pixels and a set of odd pixels; dividing
the set of even pixels into a plurality of subsets of even pixels; and
the set of odd pixels into a plurality of subsets of odd pixels; determining MBNS forms simultaneously for each pixel in
the plurality of subsets of even pixels; and
the plurality of subsets of odd pixels; and computing Discrete Fourier Transform (DFT) of the image using the MBNS forms of the pixels.
2. The computer implemented method of claim 1, wherein the set of even pixels is divided into the plurality of subsets of even pixels based upon a set of rules.
3. The computer implemented method of claim 1, wherein the set of odd pixels is divided into the plurality of subsets of odd pixels based upon a set of rules.
4. The computer implemented method of claim 1, wherein the MBNS form is determined based upon an intensity of each pixel in the image.
5. The computer implemented method of claim 1, wherein the MBNS forms include MBNS summands.
6. The computer implemented method of claim 5, wherein the DFT is computed when the MBNS summands are run through a divide and conquer method.

7. An image processing system (102) for processing an image using a multi-based
number system (MBNS), the image processing system comprising:
a processor (108) ; and
a memory (112) coupled to the processor (108), the memory (112) comprising a central module (118) configured to
receive an image, wherein the image is in a form of a pixel matrix;
segregate the pixel matrix into a set of even pixels and a set of odd pixels; and divide
the set of even pixels into a plurality of subsets of even pixels; and
the set of odd pixels into a plurality of subsets of odd pixels; a computational module (120) configured to
determine MBNS forms simultaneously for each pixel in the plurality of subsets of even pixels; and the plurality of subsets of odd pixels; and compute Discrete Fourier Transform (DFT) of the image using the MBNS forms of the pixels.
8. The image processing system (102) of claim 7, wherein the set of even pixels is divided into the plurality of subsets of even pixels based upon a set of rules.
9. The image processing system (102) of claim 7, wherein the set of odd pixels is divided into the plurality of subsets of odd pixels based upon a set of rules.
10. The image processing system (102) of claim 7, wherein the MBNS form is determined based upon an intensity of each pixel in the image.

11. The image processing system (102) of claim 7, wherein the MBNS forms include MBNS summands.
12. The image processing system (102) of claim 11, wherein the DFT is computed using the MBNS summands are passed through a divide and conquer method.
13. A computer-readable medium having embodied thereon a computer program for executing a method for image processing using a multi-based number system (MBNS), the method comprising:
receiving an image, wherein the image is in a form of a pixel matrix; segregating the pixel matrix into a set of even pixels and a set of odd pixels; dividing
the set of even pixels into a plurality of subsets of even pixels; and
the set of odd pixels into a plurality of subsets of odd pixels; determining MBNS forms simultaneously for each pixel in
the plurality of subsets of even pixels; and
the plurality of subsets of odd pixels; and computing Discrete Fourier Transform (DFT) of the image using the MBNS forms of the pixels.