Combinatorial methods for approximate image matching under translations and rotations Kimmo Fredrikssony and Esko Ukkonen Department of Computer Science, University of Helsinki PO Box 26, FIN{00014 Helsinki, Finland
[email protected],
[email protected]
Abstract
Given two{dimensional images T [1::n; 1::n] and P [1::m; 1::m] where m < n, we develop a fast rotation invariant ltration algorithm for nding the locations of approximate occurrences of P in T . In such an occurrence, each pixel of T should match the corresponding intervals of pixels de ned by P . Our lter works by extracting linear sequences of intervals, called features, from P , and by searching these from T to nd candidate positions and orientations for a whole occurrence of P . We give exact combinatorial analysis of the problem. The number of relevant orientations for P is O(m3 ) and number of di erent features of length u is O(u2 ). These can be reduced to O(m) and O(u) respectively, with heuristics. We show that the optimal feature length is O(log m) and give O(jT j log m) worst case time ltering algorithm for the problem. We conclude with experimental results. Keywords: rotation invariance; combinatorial string matching; image comparison
1 Introduction We consider the problem of nding the occurrences of a \small" image P [1::m; 1::m] inside a \large" image T [1::n; 1::n]. By occurrence we mean an area P 0 inside T that approximately matches P . One can roughly think here that P 0 is obtained by rst applying a suitable translation and rotation on P to move it on top of P 0 and then slightly perturbing the pixel values of P to obtain the pixels of P 0 . The perturbations should model the discretization error that arises when the same continuous picture is discretized in di erent ways. In our solution the perturbation (to be small enough) should keep the pixel value inside an interval of values that is de ned by pixel values in the immediate neighborhood of the pixel of P to be perturbed. We propose a ltration type algorithm for the task. The algorithm rst reads linear strings of intervals of pixels from P . The image T is then scanned, row by row to nd the occurrences of any of the strings. This is the ltration phase. Each such occurrence indicates a potential set of occurrences of whole P which are then checked (the checking phase). The two{dimensional problem that includes rotations is thus reduced to the problem of nding occurrences of one{dimensional strings. y
A work supported by ComBi and the Academy of Finland under grant 44449. The corresponding author.
Previous work on image translations and rotations has concentrated on methods that typically use template matching, cross{correlation (e.g. (Caelli and Liu, 1988)) and FFT{ techniques (Castro and Morandi, 1987). For a review, see e.g. (Wood, 1996). Combinatorial techniques that resemble ours were used in (Landau and Vishkin, 1994) and in (Takaoka, 1996). Our method is a generalization of our work of exact matching reported in (Fredriksson and Ukkonen, 1998).
2 Problem de nition
Let pattern P = P [1::m; 1::m] be a two{dimensional m m array of unit squares called pixels and text T = T [1::n; 1::n] an n n array of pixels, such that m < n (see Fig. 1), over some nite alphabet = f0; 1; ::: ? 1g. The values in are called colors. The pixel T [i; j ] is said to cover the area between its four corners, that are (i ? 1; j ? 1); (i; j ? 1); (i ? 1; j ) and (i; j ) in R2 . Each pixel has a center which is the geometric center point of the pixel, i.e., the center of the pixel for T [i; j ] is (i ? 21 ; j ? 21 ) 2 R2 . The array of pixels for pattern P is de ned similarly. The center of the whole pattern P is the center of the pixel that is in the middle of P . Precisely, assuming for simplicity that m is odd, the center of P is the center of pixel P [ m2+1 ; m2+1 ]. Consider now a rigid motion (translation and rotation) that moves P on top T: y
(9,9)
P: y’
x
(0,0)
(0,0)
center of P (5,5)
x’
Figure 1: The array of pixels for T and P (n = 9, m = 5). of T . We restrict the consideration to the special case such that the translation moves the center of P exactly on top of the center of some pixel of T . We call this the center{to{center translation. We remove this restriction in the sequel. Assume that the center of P is on top of the center of T [i; j ] after the translation. Next some rotation is applied to P . This creates angle between the x{axis of T and the x{axis of P . We now say that P is at location ((i; j ); ) on top of T . To de ne an occurrence, we need rst to de ne the matching function M at location ((i; j ); ) as follows. For each pixel T [r; s] whose center is covered by P at location ((i; j ); ), let P [r0 ; s0 ] be the pixel of P such that the center of T [r; s] belongs to the area covered by P [r0 ; s0]. Then M (T [r; s]) = P [r0 ; s0]. Matching pixels against pixels would be too great restriction in applications. For example, consider two digital images of the same scene. The images may have di erent number of colors and di erent brightness, but in principle they should match. Consider also what can happen if both P and T are obtained from some \continuous" photograph using a digital scanner. That is, the same photograph is digitized twice, and P is taken from one digitization, and T from the other. Digital images P and T may have, e.g., some systematic di erences in brightness, or in the position of the digitization grid. To this end, we de ne the interval 2
I (i; j ) of P at pattern position (i; j ). Let L(i; j ) = minfP [i + i0; j + j 0 ] j i0 ; j 0 2 f?1; 0; 1gg and H (i; j ) = maxfP [i + i0 ; j + j 0 ] j i0 ; j 0 2 f?1; 0; 1gg, and let 2 be a given parameter
that is used to adjust the interval for tighter or looser approximation. De nition 1 The interval I (i; j ) at position (i; j ) of P is I (i; j ) = [L(i; j ) ? ; H (i; j ) + ]. We base our approximate matching on the following de nition. De nition 2 Pattern P has an approximate occurrence at location ((i; j ); ) of T if for all pixels T [r; s] of T , whose center is covered by P , the color T [r; s] belongs to the interval I (r0; s0 ), where (r0; s0 ) is such that M (T [r; s]) = P [r0; s0 ].
3 The Features Let us assume that P occurs at ((i; j ); ) in the sense of De nition 2. Then it should be obvious that row i and column j of T must have around the center pixel T [i; j ] a sequence of colors that also occurs in P . Our ltration method is based on such sequences, called features. Our lter needs a feature from P for each relevant angle . If some sequence of pixels of T matches with some feature of P , then there is a potential occurrence of whole P in corresponding position of T . Whether or not this is really the case is veri ed in the checking phase. We de ne this formally as follows. Let us denote by u the length of the particular matching feature
y
y’ i
x’ α j
(0,0)
x
Figure 2: Matching feature. Pixel T [i; j + 1] matches the interval I (4; 4). feature F ( ) for angle . For simplicity, assume that u is odd. To read a feature for from P , let P be on top of T , on location ((i; j ); ). Consider the pixels T [i; j ? u?2 1 ]; : : : ; T [i; j + u?2 1 ]. We denote them as t1 ; t2 ; : : : ; tu . Let ci = I (s; t) be the interval de ned by the pixel P [s; t] of P that covers the center of ti . See Fig. 2. De nition 3 The (horizontal) feature of P with angle is the sequence of intervals F ( ) = c1 c2 c u .
3
3.1 The Angles
To calculate the set of relevant angles, we make rst the so{called center{to{center assumption, which considerably simpli es the situation. We assume that the center of P is exactly on top of the center of some pixel of T , say pixel T [i; j ]. Let us recall from (Fredriksson and Ukkonen, 1998) our result that the number of di erent functions M is O(m3 ) in location ((i; j ); ) when varies but the center of P stays at the center of T [i; j ]. Consider what happens to M when angle grows continuously, starting from = 0. Function M changes only at the values of such that some pixel center of T hits some pixel boundary of P . Some elementary analysis shows that the set of possible angles , 0 =2, is 1 (1) A = f ; =2 ? j = arcsin ph2+ 2 2 ? arcsin p 2j 2 ; i +j i +j p i = 1; 2; : : : ; bm=2c; j = 0; 1; : : : ; bm=2c; h = 0; 1; : : : ; b i2 + j 2 cg: By symmetry, the set of possible angles , 0 2, is A = A [ A + =2 [ A + [ A + 3=2 (2) Similarly, feature F ( ) can change only at angles such that some pixel boundary of P hits some center of pixels t1 ; t2 ; : : : ; tu . The set of such angles is denoted B, and these can be generated from equations (1) and (2) by setting j = 0. Obviously, the size of A is O(m3 ), the size of B is O(u2 ), and B A. Theorem 1 Assuming the center{to{center translation, there are O(u2) di erent features of length u of P . 2
Theorem 2 Assuming the center{to{center translation, there are O(m3 ) di erent matching 2
functions for each xed pixel T [i; j ] of T .
Note that M can change such that F ( ) does not change. This is handled as follows. Let ( 1 ; 2 ; : : :) be the elements of A and ( 1 ; 2 ; : : :) the elements of B in increasing order. By construction, F ( ) stays unchanged for such that i < i+1 . So F ( ) = F ( i ). However, there might be one or more angles k such that i < k < i+1 because B is a subset of A. Let us denote as K( i ) the set of such angles k . Feature F ( i ) represents all angles in K( i ) or the corresponding functions M . If we nd an occurrence of F ( i ), all the functions M that correspond to K( i ) must be checked for an occurrence of P .
4 The method Our method for nding all approximate occurrences of P in T according to De nition 2 works in the following main steps. 1. Calculate the set of angles A that contains all the angles where M changes, and the set of angles B where the features change. 2. For each in B, nd the corresponding feature F ( ). Associate with each F ( ) the set of angles K( ) A. K( ) denotes the set of orientations for P that are associated with F ( ). 4
3. Build a trie (Fredkin, 1960) F for all the features, such that each edge of the trie is labeled by some interval (see Sec. 5). 4. Scan the rows of text T and match each text position against F to nd the occurrences of features F ( ) (e.g. depth{ rst search of the trie). 5. If an occurrence of F ( ) is found centered at (i; j ) in T , check for each angle 2 K( ), whether or not P occurs at ((i; j ); ). In Section 5 we show how the features can be searched eciently.
5 Lazy{evaluation of Interval DAG There are a number of possibilities for searching the occurrences of the features. The simplest way would be to search one feature at a time. The steps 3 and 4 in our method suggest a more ecient solution, based on the trie structure, which can still be improved. The trie can have several paths matching a given string of pixels from T . These paths can be combined to a single path that represents all the corresponding features. This is achieved by labeling the edges of F by pixel colors, not intervals. This also reduces the cardinality of the trie from 2 to . Formally F = (V; E ) is a rooted tree, where V is the set of nodes and E is the set of directed edges. Each edge e = (u; v) has depth depth(e) and label label(e), such that label(e) 2 . Let H (u) be a set of features associated with some node u of the trie F . The set H (root) includes all the features. There is an edge e = (u; v) from node u, labeled with color label(e) if H (u) contains a feature R such that label(e) matches it. Let R[i] denote the ith interval of feature R. De nition 4 There is an edge e = (u; v) labeled with color label(e) in the trie if 9R 2 H (u) ) label(e) 2 R[depth(v)]: The set of features H (v) for a newly created node v is obtained as follows: De nition 5 Given an edge e = (u; v), H (v) = fR j R 2 H (u) ; label(e) 2 R[depth(e)]g: Note that if there are edges (u; v) and (u; w) such that H (v) = H (w) we can (and will) combine the nodes v and w to a single node v0 such that H (v0 ) = H (v). Now there is a unique path in the trie for each given string of pixels. If v is a leaf, then H (v) contains the corresponding matching features. The resulting trie could also be augmented by the failure{ links as used in the Aho{Corasick automaton (Aho and Corasick, 1975) to get a linear time ltering algorithm. Unfortunately in the worst case the size of the trie (with or without the failure{links) would be exponential in the number of features. We will use two ways to reduce the space requirement. Instead of a trie, we use a directed acyclic graph (DAG) D to represent the features. As many of the paths in D would not be used at all, we build D using lazy{evaluation. That is, the data structure is built as it is needed. We use the following proposition to combine di erent branches of the trie, to create a DAG: Proposition 1 If D has edges (u; v) and (q; w) such that H (v) = H (w) and depth(v) = depth(w) then the nodes v and w are combined to a single node v0 and H (v0 ) = H (v). 5
Using lazy{evaluation the size of the otherwise potentially exponentially large DAG remains polynomial in jT j. This is because each text position adds at most one path to D. The evaluation starts from a single node (root). When scanning the text, and there is no transition in D from node u for the current pixel t of T , we look the set H (u) to decide whether or not we can add, according to De nition 4, a transition from u labeled with the color of t. To keep track of the feature sets H (u) at each depth, the sets can be stored e.g. into a binary search tree. For each newly created node, we use Proposition 1 with the tree of sets to see if an equivalent node already exists. As a side e ect, after the ltering phase the paths of D spell out the pre xes of all the suxes of strings of pixels of T that match with one or more feature of P .
6 Removing the center{to{center assumption If the center{to{center assumption is abandoned, both M and the features can change without change in the rotation angle. Relaxing the assumption means, that if P has an occurrence at location ((i; j ); ), the center of P has not to be on top of the center of T [i; j ], but T [i; j ] must still cover the center of P . The de nition of the matching function M remains the same. When we are not using the center{to{center assumption we use the notation ((i ? y; j ? x); ), where 0 < x; y 1, to say that the center of P is on top of the pixel T [i; j ] at location (1 ? y; 1 ? x). Without the center{to{center assumption the number of di erent matching functions is much higher. So, instead of abandoning the assumption, we can use the following heuristic: Do not explicitly remove the center{to{center assumption, but look also the eight neighbors of each interval when extracting the features and when verifying the possible occurrence. This allows us to nd the same matches than we would without the assumption. The downside is that the ltering capability decreases and wrong positive occurrences of P may be found. The same heuristic allows to have jBj = O(u) and jAj = O(m), in both cases, center{ to{center assumption taken or removed, if the set of angles is chosen correctly. The trick is to choose such angles that the pixel p of P that is farthest away from the center of rotation moves at most distance 1 (or 21 ) at each step, which guarantees that the center of pixel t of T that is covered by p cannot move outside of its eight pixel neighborhood in P . It then follows that no center of any other pixel of T moves outside its corresponding eight pixel neighborhood. The distance p between the rotation center and the1 pixel1 p = P [m; m] farthest away from it is r = (m+1)= 2. Assume that P is at location ((i? 2 ; j ? 2 ); ), and that M (T [r; s]) = P [m; m]. We are interested in such angle ^ that if P is rotated to location ((i ? 21 ; j ? 12 ); + ^ ), then T [r; s] is covered by the area corresponding to P [m; m] or its eight neighbors for any . One such angle is p ^ = 2 arcsin 1=2r > 2=(m + 1): If T [r; s] cannot move out of the neighborhood of p, then clearly no other pixel T [r0 ; s0 ] of T covered by P can move out of its corresponding neighborhood. If the center{to{center assumption ispnot used, then p is allowed to move only distance 21 for angle ^ . This gives ^ > ((m + 1) 2)?1 : The new set of angles A^ for the orientations of P is A^ = fi ^ j 0 i ^ < 2; i 2 Ng p The size of A^ is approximately p22 (m + 1) or 2 2(m + 1) which is O(m). We have proved the following theorem. 6
Theorem 3 If P occurs at ((i; j ); ) according to De nition 2, then it also occurs at location ((i; j ); ), where ? ^ + ^ and ^ 2 A^, if pixel T [r; s] is allowed to match the interval I (r0; s0 ) and its eight neighbor intervals, where (r0; s0 ) is such that M (T [r; s]) = P [r0; s0 ]. 2
The number of features is obviously also linear in the length of the features, and the corresponding set of angles is denoted B^. This simpli es the preprocessing and makes it also slightly more ecient. However, note that now false (according to De nition 2) matches may be found. Fortunately, this false positives problem can be serious only for small alphabets or small patterns.
7 Analysis In the following analysis we assume that the set of colors is nite and that the colors of the pixels follow the uniform Bernoulli probability model. The maximum interval size (with the parameter ), de ned by the pixels of P , is denoted . Then the probability that a random pixel matches some interval is at most =, where = jj. Let us denote p = =. Brute force implementation, where each feature is searched separately using a trivial algorithm that matches the feature against the text as long as possible, requires time O(jT jjBju) on the worst case, and time O(jT jjBj=(1 ? p)) on average. That is, there are jT j positions of text where the features can occur, the number of features is jBj and the required time for each feature has geometric distribution, leading to expected time O(1=(1 ? p)) for each feature. To get optimal balance between ltering time and verifying time we calculate the optimal length for the features. Theorem 4 The optimal feature length is O(log m). Proof. The optimal length for the features can be calculated by nding the feature length that minimizes the sum of the the ltering time and the verifying time. Note that the ^ ) and hence it does not depend on the feature preprocessing time is dominated by jAj (or jAj length asymptotically. Here we use the ltering time for the brute{force searching of the features. However, the more complex ltering algorithms lead also to logarithmic optimal feature lengths. The optimal feature length ` is given by the following equation ( is a small constant):
d jT jjBj=(1 ? p) + jT jjAjp` =(1 ? p) = 0 d` p)={z(1 ? p}) p` = 0 ) 2|=(1{z? p}) ` + jAj (ln | a
b
) ` = logp ` ? 3 logp m + ) ` = O(log m) 2 This implies that reasonably short features can be used. This is also good news for the space requirement. The lazy evaluation of the interval DAG creates at most O(jT ju) nodes, as each text position adds at most one path of length u to the DAG. In practice, however, the situation is much better, in our experiments (see Sec. 8), the number of nodes is between 0:025 jT j and 2:95 jT j, and usually less than jT j. The size of set H (w) will diminish as depth(w) grows. If there is an edge (v; w), then jH (w)j pjH (v)j. Eventually jH (w)j will be driven to O(1) in high probability. This means 7
that at certain depth i in D there are only jBj nodes, as all other nodes are combined. The depth i is
pijBj = 1 ) i = ? logp jBj At level i, D has converged to the maximum breadth of the corresponding trie where the edges are labeled with intervals. This means that the maximum size of D is at most i + ujBj = O(i ) = O(jBj? logp ). On the other hand, the size depends also on the number of di erent strings of length u of T . The number of nodes in some depth i is at most i . Given a random string of pixels, it matches to a given string of intervals up to depth i in probability pi , in which case a new node may be created in depth i of D. There are O(jBj) di erent strings of intervals for each of the O(jT j) di erent strings of pixels of T , hence the expected maximum number of nodes in D is m X i
minfi ; jBjjT jpi g
logX c jBjjT j
i
i +
m X i=logc jBjjT j+1
jBjjT jpi = O((jBjjT j)log ) c
where c = 2 =. So the number of nodes in D is at most ? log log p c O(minfjBj ; (jBjjT j) ; jT jug). Using theorems 3 and 4 we get O(minf(log m)? logp ; (jT j log m)logc g). The time spend for creating each node is in the worst case O(u), which by theorems 3 and 4 is O(log m). Using bit{parallelism for representing and computing the feature sets associated with the nodes, the time for each node can be reduced to O(d logwm e), where w is the number of bits in the machine word. In the RAM model of computation, d logwm e = O(1). Theorem 5 By using theorems 3 and 4 the worst case ltering time is O(jT j log m). 2 Note that Theorem 5 holds also when we use O(log m) features and the full O(m3 ) sized set A of angles and center{to{center assumption in the veri cation phase. Theorem 6 The expected number of checkings is O(jT jjBjpu) and expected checking time is O(jT jjAjpu=(1 ? p)). Proof. Note that the probability that a feature matches has binomial distribution, and hence the expected total number of matchings is jT jjBjpu . There are O(jAj=jBj) angles to check for each matching feature. In the Bernoulli model the time for each verifying has geometric distribution, which leads to O(1=(1 ? p)) expected verifying time for each angle, and hence the expected veri cation time is O(jT j=(1 ? p)(jAj=jBj)jBjpu ) = O(jT jjAjpu =(1 ? p)): 2
8 Experiments The described method was implemented in C, and compiled using gcc version 2.7.2.3 running on Linux operating system on 450MHz Pentium II computer. For the experiments a set of photographs were scanned, each in two di erent orientations, and the pattern was then manually taken from the other of the digitized pictures. This pattern was then searched from the other picture. Results are shown in Tables 1, 2 and 3. Voltolina and rousseau images are paintings and the corresponding patterns are the heads of one of the characters illustrated. Owl and owls are photographs of sitting owl(s), and the patterns are the eyes of an owl. Dog 8
is a photograph of two dogs. There are three corresponding patterns, the eye of one of the dogs, and two larger patterns showing the head of the dog. The patterns are illustrated in Fig. 3. The original number of colors in the images were reduced to the value shown in Table 1. This reduces the size of the DAG. The images are black and white. Color (RGB) images can be searched by extracting one set of features for each color component and ltering for each component separately, requiring a match for all three components. The feature lengths Case voltolina rousseau owl owls dog eye dog head dog big-head
jT j 607 220 435 182 247 284 697 464 575 277 575 277 575 277
jP j 23 23 21 21 17 17 29 29 15 15 41 41 71 71
4.2 5.6 8.9 4.6 4.4 4.2 3.3
15 16 22 16 13 29 29
Table 1: The set of images for the experiments. Here denotes the mean interval of the pattern.
Figure 3: Patterns for the experiments. Case owl dog eye dog head dog big-head
4 6 16 20
preprocessing time ltering time veri cation time # matching features 1 0.02 0.75 2.16 24961 0 0.01 0.15 14.07 107015 1 0.36 4.42 3.81 10432 1 2.11 5.08 17.18 9842
# nodes 29449 5556 248534 291233
Table 2: The experiments using the sets A and B of angles. is user de ned parameter for widening the interval. The times are given in seconds. The number of matching features and the number of nodes in the resulting DAG are also shown. = 1 in all cases. were calculated from equation (c.f. the proof of Theorem 4) ` = logp m + where and are user speci ed constants. Here p = ( + 2)=, where is as in Table 1 and is the user speci ed parameter as in De ninion 1. For the experiments of Table 2 the exact sets of angles were used, whereas for the experiments of Table 3 only a linear number of angles were used. However, the neighboring intervals were not looked at, as suggested in Sec. 6. Still, the correct match was found in each test case. Table 3 shows also the e ects of varying and . The experiments indicate that the method is fast, and can nd occurrences of P that have reasonably close counterparts in T . The sets H (u) were implemented as simple lists of ranges of features. If jBj = O(log m), then the sets could be implemented using bit{vectors for greater eciency. The size of D is 9
Case voltolina rousseau owl owl owl owls dog eye dog eye dog head dog head dog head dog head dog head dog head dog big-head
6 6 3 3 3 5 6 6 4 5 6 7 8 7 9
1 1 1 2 3 1 0 1 1 1 1 1 1 2 1
ltering time veri cation time # matching features # nodes 2.38 4.07 425318 162048 3.50 2.91 316654 233083 0.21 0.17 21087 9281 0.50 0.59 89607 27331 0.67 1.29 210352 37918 5.48 16.81 1302479 277312 0.11 0.36 37360 4076 0.23 10.45 669124 8208 0.10 5.55 191347 3486 0.31 1.82 82907 12987 0.48 1.15 60894 20918 0.64 0.75 44644 28790 0.87 0.52 36386 41019 1.99 2.12 122074 108060 1.61 1.95 95107 79657
Table 3: The experiments using the linear sized sets A^ and B^ of angles. The times are in seconds. Preprocessing time is 0.00 and = 1 in all cases. potentially large. However, many of the states that are far from the root, are used only once. Those could be removed as more space is needed. Another solution is to build the DAG only to a certain depth, and use other methods from there on, e.g. trie or brute{force search.
9 Conclusions An important property of our method is, that it generalizes in a straight{forward manner for handling any number of patterns at the same time. The features of di erent patterns can be stored to the same trie/DAG and searched simultaneously. This is an important consideration from the practical point of view, where one may have a dictionary of patterns of interest. Our analysis of the matching function may be of interest also for some other pattern matching techniques that use sampling of some form. The ltration can be improved by scanning T in two directions, along the x{axis and also along the y{axis. The veri cation is invoked only if two perpendicular features are found for some location of P . The veri cation procedure could also be improved by verifying the possible candidate rotations using incremental techniques. This is possible because the matching function changes only for a few pixels for consecutive angles. The method can also be generalized to allow small number k of mismatches of pixels. To eciently handle this, one might take f distinct sets of features from P and search them with only bk=f c mismatches.
References
Aho, A. V. and Corasick, M. J. (1975). Ecient string matching: an aid to bibliographic search. Communications of the ACM, 18(6):333{340. Caelli, T. M. and Liu, Z. Q. (1988). On the minimum number of templates required for shift, rotation and size invariant pattern recognition. Pattern Recognition, 21:205{216. Castro, E. D. and Morandi, C. (1987). Registration of translated and rotated images using nite fourier transforms. IEEE Transactions on Pattern Analysis and Machine Intelligence, PAMI-9(5):700{703. Fredkin, E. (1960). Trie memory. Comm. A.C.M., 3(9):490{499.
10
Fredriksson, K. and Ukkonen, E. (1998). A rotation invariant lter for two{dimensional string matching. In Proceedings of the 9th Annual Symposium on Combinatorial Pattern Matching, Lecture Notes in Computer Science, pages 118{125. Springer-Verlag, Berlin. Landau, G. M. and Vishkin, U. (1994). Pattern matching in a digitized image. Algorithmica, 12(4/5):375{408. Takaoka, T. (1996). Approximate pattern matching with grey scale values. In Houle, M. E. and Eades, P., editors, Proceedings of Conference on Computing: The Australian Theory Symposium, pages 196{203, Townsville. Australian Computer Science Communications. Wood, J. (1996). Invariant pattern recognition: a review. Pattern Recognition, 29(1):1{17.
11
