KR100839391B1 - Fast signal convolution using separated-spline kernel - Google Patents

Abstract

This can be accomplished using a fast convolution method that can be used to convolve a signal (n-dimensional (n represents a pattern of two or more)) with a smooth kernel that can be approximated by a separate-spline kernel, and software or signal processing circuitry. A system configured to perform a method. Unlike the Fourier-based convolution method, which requires NlogN order arithmetic operations on signals of length N, the method of the present invention requires only N order arithmetic operations to do so. Unlike the wavelet-based convolution approximation (convolution of the same signal typically requires more arithmetic operations than in accordance with the present invention), the method of the present invention is suitable for a convolution kernel which is a spline kernel.

Isolated Spline Kernel, Convolution

Description

FAST SIGNAL CONVOLUTION USING SEPARATED-SPLINE KERNEL}

Cross Reference of Related Application

This application is part of pending US patent application Ser. No. 09 / 480,908, filed on January 11, 2000 by Richard E. Crandall, assigned to Etec Systems, Inc. See, here, the entire US patent application Ser. No. 09 / 480,908.

Field of invention

The present invention relates to a signal processing method and apparatus for performing convolution on data representing a pattern (eg, image data representing a pixel array). According to the invention, the convolution kernel is a discrete-spline function (or approximated to a discrete-spline function).

Background of the Invention

Convolution is generally performed on many context signals, including the fields of sound, still image, video, lithography, and radio (radar) signal processing. Typically, the signal to be convolved is a pattern signal. Here each representation of "pattern" and "pattern signal" is a broad representation of a one-dimensional sequence of data words (which may be pixels, but not necessarily pixels) or a two-dimensional (or higher dimension) array. Used as a concept. Typically, data words are made up of binary bits, and convolution is performed in a discrete manner on binary bits using software, digital signal processing circuitry, commodity hardware, or field programmable gate array based computing systems.

The term "data" herein refers to one or more signals representing data, and the expression "data word" means one or more signals representing data words.

Even when processing data representing very large patterns, there are numerous motivations to implement convolution at high speed. The present invention has been motivated by the need for proximity correction in the field of lithography. In this problem, one attempt is a two-dimensional convolution between the data representing the large pattern "p" (in this case, the pattern is a pixel array) and the spreading kernel "d". Often the kernel "d" is a Gaussian, Gaussian superposition, or otherwise a smooth kernel. More specifically, the present invention uses a Gaussian kernel (or other smoothing kernel) to make the convolution very accurate or very close to a two-dimensional pattern consisting of NN 'pixels (in which case each of N and N' are very large). An attempt was made to establish an appropriate "O (NN ')" algorithm (an algorithm that does not require multiplication and addition above the NN' order) to convolve.

The purpose of performing proximity correction (in the field of lithography) can be input into a set of reflective or refractive optics (or electron beam optics) to cause the output of the optics to produce a predetermined pattern on a mask or wafer. To generate a "raw" optical signal (or a "raw" electron beam signal). In order to determine the properties of the raw optical signal (or raw electron beam signal) required to generate a predetermined pattern on a mask or wafer, it is usually very necessary to determine the well known proximity problem (to determine the pattern "p"). Perform a deconvolution operation on a large array of pixels. In electron beam lithography, proximity problems arise due to electron scattering in the substrate (mask or wafer) being written. This scattering effectively extends the electron beam beyond the beam diameter incident on the substrate, thereby exposing a large area on the substrate (ie the region surrounding each pixel to be written as well as the pixel itself) to the electron.

In almost all proximity calibration schemes, this deconvolution operation involves one or more convolution steps. Thus, in performing conventional proximity correction, very large pixel arrays (determining the pattern "p") must be convolved with a diffusion kernel. Such convolution is typically performed on a pattern consisting of a very large binary pixel array, but this limitation is not necessary in the following discussion and is not essential to the implementation of the present invention. Indeed, the present invention may implement a convolution for data representing any pattern "p" using a smooth convolution kernel "d" with the features described below.

및, 인덱스의 제한 (indicial constraint) 과 범위에서만 차이가 있는 비순환적 컨볼루션 (acyclic convolution)

을 고려하는데, 여기서

는 컨볼루션 연산자가 순환적 특성을 갖는 것을 의미하고,

는 컨볼루션 연산자가 비순환적 특성을 갖는 것을 의미한다. Cyclic convolution on data representing pattern "p" and convolution kernel "d"

And acyclic convolution, which differs only in individual constraints and ranges of the index.

Consider, where

Means that the convolution operator has recursive properties,

Means that the convolution operator has acyclic properties.

For simplicity, many discussions here are limited to the one-dimensional case (pattern p is an ordered set of N data values and the kernel is an ordered set of M values). Nevertheless, for a typical embodiment of the present invention, the pattern is a two-dimensional (two-dimensional array of data values p _jk determines the pattern) and a sum defining convolution (one of the sums described in the paragraph above) It can be seen that the sum corresponding to exceeds not only the index j of the array p _jk but also the index k. For a two-dimensional pattern p determined by an N × N ′ array of data values, the index (n, i, j) and domain length (N) in the formula described in the paragraph above are two-vectors.

In the one-dimensional case, the result of cyclic convolution has a length of N (the result of cyclic convolution consists of N data values), and the result of acyclic convolution has a length of M + N-1. .

은 등가의 매트릭스-벡터곱

으로 계산될 수 있는데, 이 경우, D 는 d 의 회전 매트릭스 (circulant matrix ; 이하, d 의 "회전"이라 함) 로서, D 의 1-차원 형태 (N 은 3 보다 크다고 가정함) 는 다음과 같이 정의된다. Circular Convolution

Is the equivalent matrix-vector product

Where D is the rotation matrix of d (hereinafter referred to as "rotation" of d), where the one-dimensional form of D (assuming N is greater than 3) is Is defined.

Thus, the conventional method for cyclic convolution can be calculated in the language of matrix algebra. Acyclic convolution can be obtained with similar matrix manipulation.

For simplicity, in the following, the symbol x is used to denote a convolution with either acyclic or cyclical characteristics. In most discussions, this symbol means convolution with acyclic properties. One skilled in the art can implement the corresponding cyclic convolution by slightly modifying parameters (e.g., boundary conditions and definitions for kernel rotation) that determine acyclic convolution given a particular acyclic characteristic. It can be seen that there is.

The above-mentioned U.S. Patent Application Serial No. 09 / 480,908 discloses a smooth kernel d by the spline kernel f of the polynomial (f is the spline function f (x) which is the division polynomial f _i (x) of order δ with L divisions). After approximation, using the appropriate operator to decay (flatten) each polynomial of a given order (in the manner described below) in order to compute the convolution of f and p at high speed is the central idea (in the one-dimensional embodiment). Convolution methods are disclosed. In some embodiments, smooth kernel d is not a polynomial spline kernel, but is also approximated by a spline kernel f consisting of L distinctions defined for adjacent segments of its domain (in the latter two-dimensional case, the latter spline The kernel is a radial symmetric function in which the domain is a continuous or discrete set of values for the radial parameter). A "spline" convolution, as described in US patent application Ser. No. 09 / 480,908, is an O (N) algorithm (such as a wavelet method) that is reminiscent of the conventional wavelet method, but the benefits of "spline" convolution Can be performed with cN arithmetic operations (for data representing a pattern p of N data values), whereas conventional wavelet convolution on the same data requires bN arithmetic operations, in which case , Factor "b" is typically much larger than factor "c" (ie, for conventional error analysis). In other words, the implied big-O constant inherent in spline convolution is much smaller than this constant, which is typical for conventional wavelet convolution.

Spline convolution as disclosed in US patent application Ser. No. 09 / 480,908 performs cyclic or acyclic convolution of pattern "p" (ie, data representing pattern "p") using smooth spread kernel d, The convolution result is a method of generating data representing r = Dp (where D is the rotation of d). The pattern “p” may be one-dimensional in that it may be determined by a continuous (or discrete) one-dimensional domain of data values (or pixels), or a continuous two-dimensional domain (or discrete) of data values Can be two-dimensional, and p can have a dimension greater than two. In a typical discrete implementation, the pattern p is determined by a discrete, ordered set of data values (e.g., pixels) p _i (i varies from 0 to N-1, where N is the length of the signal). Is one-dimensional at or is two-dimensional in that it is determined by an array of data values p _ij (i varies from 0 to N-1, j varies from 0 to N'-1), or is greater than 2 Has a dimension (determined by a three-dimensional or higher-dimensional set of data values). Typically, the kernel d is determined by an array of data values d _ij (i varies from 0 to N-1, j varies from 0 to N'-1), but alternatively the kernel d is from d ₀ to d may be determined by a discrete set of data values of _N-1 ).

In some embodiments disclosed in US patent application Ser. No. 09 / 480,908, convolution Dp is

(a) approximating kernel d by the polynomial spline kernel f (if kernel d itself is a polynomial spline kernel, d = f and step (a) is omitted);

를 계산하는 단계 (F 는 커널 f 의 회전이고,

는

가 희소 (sparse) 해지는 방식으로 회전 F 에 대해 작용하는 소멸화 (annihilation) 연산자로서 그 형태는 일반적으로 f 의 다항식 세그먼트에 대한 차수 δ에 의존한다); 및 (b) q = Bp =

(F is the rotation of kernel f,

Is

As an annihilation operator that acts on rotation F in such a way that it becomes sparse, its form generally depends on the order δ for the polynomial segment of f); And

를 거꾸로 풀어내는 단계를 수행하는 것에 의해 실현된다.(c) to determine r = Fp,

It is realized by performing the step of unwinding backwards.

If the kernel d itself is a polynomial spline kernel (and therefore d = f and F = D), the method yields the correct result (r = Dp). Otherwise, the error inherent in this method is (f-d) xp (x represents convolution), so the error is easily limited.

는 다음에 정의된 바와 같은 N ×N 의 회전 매트릭스 형태를 갖는데, For one-dimensional (where the pattern to be convolved is a one-dimensional pattern of length N),

Has the form of a rotation matrix of N × N, as defined below:

In this case, each entry is a binomial coefficient, and δ is the maximum order of the spline segment for the spline kernel f. For example, when the spline kernel f consists of quadratic segments, δ = 2. For orders of two or more, the destructive operator can be defined as

는 d 좌표의 h-번째에 대한 n-번째 편도함수 (partial derivative) 이다. in this case,

Is the n-th partial derivative of the h-th of the d coordinate.

For example, Laplacian,

Destroy the division-plane function (f = f (x ₁ , x ₂ , ..., x _d )) of the _d -dimensional argument.

In the one-dimensional case, the end point of each segment ("pivot points") for the spline kernel f may be a contiguous element d _i and d _{i + 1} of the kernel d, and step (a) Can be implemented by performing curve fitting to select each segment of the spline kernel as appropriately matching the corresponding segment of kernel d. In some implementations, appropriate boundary conditions are met at each pivot point by matching a derivative to the pivot point or meeting some other smoothing criteria.

In some implementations disclosed in US patent application Ser. No. 09 / 480,908, step (c) is a preliminary "ignition" in which the smallest number of components of r = Fp is calculated by the correct multiplication of p by the few rows of F. And a subsequent step of determining the remaining components of r using the natural regression relationship determined by the spline kernel and operator Δ _{δ + 1} . For example, in the one-dimensional case, the lowest component of r is r ₀ , r ₁ , ..., r _δ (in this case "δ" is the highest order for the spline segment of spline kernel f) For example, if the spline kernel consists of secondary segments, r ₀ , r ₁ and r ₂ ), and these (δ + 1) components are determined by the exact multiplication of p by the (δ + 1) rows of F . Alternatively, the (δ + 1) components may be determined in other ways. Then, the rest of the "r _δ " component is determined using a natural recurrence relation determined by the operator Δ _{δ + 1} . The "ignition" operation of generating r ₀ , r ₁ , ..., r _δ components can be realized with O (N) calculations. Regression relationship calculations can also be realized with O (N) calculations.

In another embodiment, a method of performing convolution r = Dp disclosed in US patent application Ser. No. 09 / 480,908,

(a) approximating kernel d by the polynomial spline kernel f (if kernel d itself is a polynomial spline kernel, d = f and step (a) is omitted);

를 계산하는 단계 (F 는 커널 f 의 회전이고,

는

가 거의 모든 곳에서 국부적으로 일정한 매트릭스가 되도록 회전 F 에 대해 작용하는 평탄화 (flattening) 연산자로서 그 형태는 일반적으로 F 의 다항식 세그먼트에 대한 차수 δ에 의존한다); 및(b) q = Bp =

(F is the rotation of kernel f,

Is

As a flattening operator acting on rotation F such that is a local constant matrix almost everywhere, its form generally depends on the order δ for the polynomial segment of F); And

를 거꾸로 풀어내는 단계를 포함한다. (p 가 길이 N 을 갖는) 1-차원인 경우에,

는 다음과 같은 N ×N 의 회전 매트릭스 (circulant matrix) 형태를 갖는데, (c) to determine r = Fp,

Including the step of loosening upside down. If p is one-dimensional (with length N),

Has the form of a circulant matrix of N × N

는 유사하게 정의된다.In this case, each entry is a binary term coefficient, and δ is the maximum order of the spline segment for the spline kernel f. Flattening operator, even for higher dimensions

Is defined similarly.

In another embodiment disclosed in US patent application Ser. No. 09 / 480,908, convolution Dp (D is the rotation of smooth kernel d),

(a) approximating kernel d by spline kernel f rather than polynomial spline kernel (if kernel d itself is such a spline kernel other than polynomial spline kernel, d = f and step (a) is omitted) ;

(b) calculating q = Bp = AFp (F is the rotation of kernel f, and A acts on rotation F in such a way that AF = B becomes sparse if A is an extinction operator, and A is In the case of a flattening operator, AF = B is an extinction or flattening operator that acts on rotation F in such a way that it is a local constant matrix almost everywhere); And

(c) solving Ar = q backwards to determine r = Fp.

In order to better understand the advantages of the present invention over conventional convolution methods, two forms of conventional convolution methods, Fourier-based convolution and wavelet-based convolution, are described below. Describes wavelet-based convolution.

As is well known, Fourier-based convolutions have F in which the Fourier matrix,

If F _jk = e ^{-2πijk / N} ,

Since the transformation FDF ^-1 of rotation is diagonal,

Dp = F ^-1 (FDF ^-1 ) Fp

Is computed, the rightmost Fp is the usual Fourier transform, the operation by the parentheses is a dyadic multiplication (by the diagonal), and the last F ^-1 operation is the inverse Fourier transform. . For arbitrary D, the creation of the diagonal matrix FDF- ¹ requires one transformation, so actually three Fourier transforms are needed. By the way, if D is fixed and converted on a one-time basis, subsequent convolutions Dp only require two transformations each, as is well known. Therefore, since two or three Fast Fourier Transforms (FFTs) are required, the complexity of the Fourier-based cyclic convolution for convolving a pattern p of length N (pattern determined by N data values) is ( That is, O (NlogN) operation for multiplication and addition of NlogN orders. The Fourier method is an accurate method (can eliminate errors that depend on FFT accuracy).

Another classification of conventional convolution methods consists of wavelet convolution methods, which, due to their nature, are generally inaccurate. The idea underlying this method is clear and proceeds according to the matrix-algebra paradigm below. Assuming a given N × N rotation D, we can find a matrix W (usually a compact wavelet transform) with

(1) W is single (ie, W ⁻¹ is an accompanying matrix of W);

(2) W is rare; And

(3) WDW ^-1 is rare

In this case, “sparse” in this context simply means that any matrix-vector product Wx for any x is associated with reduced complexity O (N) rather than O (N ² ).

Using the hypothesized features, in the manner of three sparse-matrix-vector multiplications,

Dp = W ^-1 (WDW ^-1 ) Wp

The unitarity implies the sparseness of W ⁻¹ . Thus, a wavelet for convolving the pattern p determined by the N data values, except where it is generally impossible to find a matrix W that precisely applies sparse properties to both for a given rotation D. The base convolution complexity is O (N). Typically, if the convolution kernel d is sufficiently smoothed, one can find the wavelet operator W (which is a sparse matrix) so that the above feature (3) holds within some acceptable approximation error. The above-mentioned features (1) and (2) are common to at least a family of compact wavelets (where feature (3) is generally approximation).

The advantage of a "spline" convolution (in accordance with the teachings of US patent application Ser. No. 09 / 480,908) to conventional wavelet convolution is that it is based on cN arithmetic operations (for data representing a pattern p of N data values). On the other hand, conventional wavelet convolution for the same data requires bN arithmetic operations, in which case the factor "b" (assuming a normal error budget) is greater than the factor "c". Much bigger. An important other advantage of the "spline" convolution method of patent application 09 / 480,908 (for conventional convolution methods) is that while the wavelet convolution scheme is approximate by design (and error for wavelet convolution) While analysis is difficult to implement), spline convolution is accurate for spline kernel f; The signal lengths for the signals to be convolved by spline convolution are not limited (ie, they do not need to be powers of two as in some conventional methods, and in fact they do not have to have any special shape); Because of spline convolution, acyclic convolution does not require padding at zero.

Isolated-spline convolutions (such as spline convolutions according to US patent application Ser. No. 09 / 480,908) are O (N) methods for convolving a pattern p determined by N data values. The isolated-spline convolution according to the invention can be performed with dN arithmetic operations (multiplication and addition) (for data representing a pattern p of two or more dimensions consisting of N data values), while US patent application 09 / In that the spline convolution according to 480,908 requires cN arithmetic operations on the same data, the isolated-spline convolution according to the present invention has an advantage over the spline convolution according to US patent application Ser. No. 09 / 480,908. (Factor "c" is greater than factor "d", typically much larger). In other words, the inherent large-O constants for isolated-spline convolutions according to the present invention are better than the conventional inherent large-O constants for spline convolution as described in US patent application Ser. No. 09 / 480,98. Remarkably small

Summary of the Invention

In the classification of embodiments, the present invention performs a two-dimensional cyclic or acyclic convolution of n-dimensional pattern "p" (ie, data representing n-dimensional pattern "p") with smooth spread kernel d by , Convolution results

r = Dp = d × p

(In this case n ≧ 2, D is a rotation matrix (also referred to herein as “rotation”) of d, and “×” represents convolution). The two-dimensional pattern p is determined by a continuous two-dimensional range of data values or a two-dimensional array of discrete data values. For a typical discrete implementation, the pattern p is a discrete pattern of data values (e.g. pixels) p _ij (i varies from 0 to N-1 and j varies from 0 to N'-1). And is two-dimensional in that it is determined by the ordered set. If the pattern p has a dimension greater than 2, the pattern is determined by a set of data values in three or higher dimensions. Typically, kernel d is determined by an array of data values d _ij (i varies from 0 to N-1 and j varies from 0 to N'-1).

In a preferred embodiment, the inventive method of performing convolution r = Dp = d × p (where d is well approximated by the split-spline kernel (or same as split-spline kernel)),

(a) k (x ₁ , ..., x _n ) = k ₁ (x ₁ ) k ₂ (x ₂ ) ... k _n (x _n ) (in this case, k is the operator A = A ₁ A ₂ ... allows A _n , where n is the dimension of the pattern p, and A _j is (if A _j is a destructive operator) A _j K _j is sparse (if A _j is a smoothing operator) A _j K _j Is a destructive or flattening operator that acts on the rotation K _j of the kernel k _j , in such a way that it is a local constant matrix almost everywhere);

(b) calculating q ₁ = A ₁ k ₁ × p for each row of the pattern p;

(c) performing a preliminary ignition step of directly calculating a few r ₁ components and then determining the remainder of the r ₁ components using the natural regression relationship determined by operator A ₁ , thereby determining A ₁ for each row of the pattern. solving r ₁ = q ₁ backwards to determine r ₁ = k ₁ x p for the pattern;

(d) substituting r ₁ = k ₁ × p generated in step (c) to generate r ₁ ^T = (k ₁ × p) ^T for the pattern, and for each row of (k ₁ × p) ^T calculating q ₂ = A ₂ k ₂ xr ₁ ^T = A ₂ k ₂ x (k ₁ xp) ^T ; And

(e) solving A ₂ r ^T = q ₂ for each of said rows of (k ₁ × p) ^T backwards to determine r ^T = (k ₂ × k ₁ × p) ^T for the pattern .

If the pattern p is two-dimensional (n = 2), the result of step (e) is typically substituted to generate data representing r = (k ₂ x k ₁ x p), where the result r is Is exactly equal to k × p, which is an approximation of a given convolution r = Dp.

으로 정의된다.If p is an n-dimensional (n> 2) pattern, (for i-th iteration, q _i = A _i k _i × q _i-1 for the _i- th dimension is calculated) and for each additional dimension they are In that each is repeated, steps (d) and (e) are repeated, and the substitution for the last repetition result of step (e) is exactly the same as k x p, which is an approximation to a given convolution r = Dp. For an n-dimensional array M (with axes i ₁ , i ₂ , ..., i _n ), the multidimensional substitution is

Is defined.

In some implementations of step (c), the few lowest components of r ₁ are calculated directly during the preliminary ignition step, and then the remainder of the r ₁ components is determined using the natural regression relationship. In a preferred implementation of step (c), the few large negative components of r ₁ are calculated directly during the preliminary ignition step and then the natural regression relationship is used to determine the remainder of the r ₁ components.

If the kernel d itself is a split-spline kernel (and therefore d = k and K = D), this method yields the correct result (r = Dp). Otherwise, the error inherent in this method is (k-d) x p, so this error is easily limited.

In one class of preferred embodiments where the pattern p is two-dimensional, the two-dimensional kernel is defined as k (x, y) = k ₁ (x) k ₁ (y), in which case

to be. The one-dimensional kernel k ₁ (x) has three parts:

In this case, k _c (x) is the kernel

k ₊ (x) is the one-tailed Laplacian kernel,

k _- (x) is the Laplacian kernel of the next one-sided, such as.

인) 2 개의 감쇠 영역은 상이한 컨볼루션에 의해 각각 생성되며, 이들의 결과를 함께 가산하여 최종 결과를 획득한다.Each one-dimensional convolution is performed in three parts. (| X | ≤ R) cap and (

The two attenuation regions are each created by different convolutions, and their results are added together to obtain the final result.

More specifically, in the above classification of embodiments, the method of the present invention,

(a) specifying a separate-spline kernel as k (x, y) = k ₁ (x) k ₁ (y), in which case k ₁ (x) is defined in the previous paragraph;

(b) cap convolution k _c × p (x) for each row of pattern p, second convolution k ₊ × p (x) for each row, and third convolution k ₋ for each row; Calculate xp (x) and add together the cap convolution, the second convolution and the third convolution for each row,

Generating data indicative of

Cap convolution calculates A _c k _c × p for each row above

로서 정의되는 소멸화 연산자), (In this case, A _c

Destructive operator, defined as

를 이용하여

를 계산함으로써 실현되고,Regression relationship

Using

Is realized by calculating

delete

The second convolution calculates A ₊ k ₊ x p (x) for each row above

로서 정의되는 소멸화 연산자), (In this case, A ₊

Destructive operator, defined as

를 이용하여

를 계산함으로써 실현되고,Regression relationship

Using

Is realized by calculating

delete

The third convolution of A for each of the _line-and calculating × p (x) _- k

로서 정의되는 소멸화 연산자), (In this case, A _- is

Destructive operator, defined as

를 이용하여 끝에서부터 시작까지 회귀하는 것에 의해

를 계산함으로써 실현되는, 단계;Regression relationship

By returning from end to beginning using

Realized by calculating;

delete

(c) substituting (k ₁ × p) to generate (k ₁ × p) ^T ;

_{(d) p (k 1 ×} p) than the line of the by repeating step (b) for the rows of ^T, the k ₁ further comprising: convolutional all columns of k ₁ × p; And

(e) substituting the result of step (d) to generate data representing r = k × p, where p is a two-dimensional pattern and d is well approximated by (or with) a separate spline kernel We realize convolution r = d × p, which is the same kernel.

Typically, the pattern p (x, y) is stored in memory before step (b), and each iteration of step (b) is performed on a different row of pattern p (x, y) read from the memory, and step (c) storing (k ₁ × p) ^T in memory such that each row of (k ₁ × p) ^T occupies a storage location previously occupied by the corresponding row of p (x, y) It includes. Optionally, the last step (step (e)) is omitted.

In another class of preferred embodiments where the pattern p is two-dimensional, the two-dimensional kernel is defined as follows.
k (x, y) = k ₂ (x) k ₂ (y), where

이다.

to be.

One-dimensional kernel k ₂ (x) has two parts as follows,

k ₂ (x) = k _c (x) + k _i (x)

In this case, k _c (x) is the kernel

k _i (x) is

More specifically, in an embodiment where k (x, y) = k ₂ (x) k ₂ (y) with k ₂ (x) as defined in the previous paragraph, convolution r = d × p (d is The method of the present invention performing a good approximation (or the same as a discrete-cosine kernel) by a discrete-cosine kernel,

(a) specifying a discrete-cosine kernel as k (x, y) = k ₂ (x) k ₂ (y);

(b) For each row of the pattern p (x, y), performing the following two steps: (i) For -R-3 <x <n-1, the value Ak ₂ for each row above Calculate × p as:

Ak ₂ (x) × p (x) = 2sin ² (π / 2L) (p (x + R) + p (x + R +1))-p (x -R)-p (x -R +1 )); And

(ii) the regression relationship r (x + 2) = Ar (x) + 2sin ² (π / 2L) (r) to find r (x) = A ^-1 (Ak ₂ xp) for each row above (x + 1)-r (x)) + r (x-1), and the relationship r (-R-4) = r (-R-3) = r (-R-to ignite the regression operation 2) generating data representing k ₂ × p at the end of the last iteration of step (ii) by performing a regression operation with = 0;

(c) by substituting _{k 2 × p (k 2 ×} p) generating a ^T; And

by (d) repeating step (b) for non-line of p (k ₂ × p) ^T of the line, and a step of convolution all columns of ₂ k × ₂ k to p.

Preferably, steps (a) to (d) are performed by a suitably programmed processor, which, after step (d), (e) substitutes the result of step (d) to generate r (x, y). And further returning to the initial processor state. In a variation on embodiments of this classification, each occurrence of factor 2sin ² ([pi] / 2L) is replaced with factor 1.

In another embodiment, the invention uses software to perform convolution on data representing an n-dimensional pattern, in which case n is two or more, using a detachable kernel in accordance with any embodiment of the method of the invention. It is a computer programmed. Another embodiment of the invention is configured to perform convolution on data representing an n-dimensional pattern, in which case n is 2 or more, using a detachable kernel according to any embodiment of the method of the invention. A digital signal processor comprising a digital signal processing circuit, an apparatus (such as a commercial or dedicated electronic circuit, or an "FPGA system") configured to perform convolution on such data in accordance with any embodiment of the method of the present invention. And lithographic systems including such digital signal processing circuits, such commercial or proprietary electronic circuits, or such FPGA systems.

Computer-readable storage media storing computer-readable instructions that, in response to execution of the instructions, cause the computer to perform embodiments of the method of the present invention, also fall within the scope of the present invention.

Brief description of the drawings

1 is a block diagram of a computer system programmed with software implementing the method of the present invention.

2 is a digital signal processor configured to perform convolution (according to the invention) on image data, and thus a pattern signal (e.g., optical beam, electron beam whose amplitude varies with time) from the convolved image data. Is a block diagram of a lithographic system that includes an apparatus for generating a system. The pattern signal is applied to a set of optical systems (e.g., reflective or refractive optical systems, or electron beam optical systems), and the output of the optical systems is projected as a pattern on a glass plate, thereby creating a mask useful for fabricating integrated circuits.

3 is a block diagram of a digital signal processor (which may be used with the digital signal processor of FIG. 2) configured to perform convolution (according to the invention) on image data.

4 is a block diagram of a lithographic system, which is a variation on the system of FIG.

5 is a simplified front view of a computer-readable storage medium (CD-ROM) storing computer-readable instructions for causing a computer to perform embodiments in accordance with the methods of the present invention in response to execution of the instructions.

Detailed Description of the Preferred Embodiments

Throughout the specification, including the claims, the term “data” means one or more signals representing data words. Thus, the statement that data representing pattern "p" is convolved (according to the invention) with data representing smooth kernel "d" means that one or more signals representing pattern p represent another set of one or more other signals representing kernel d. Means that data (ie, one or more signals) is generated that is processed to represent the convolution result.

Preferred embodiments of the present invention are described with reference to the "extinction" and "flattening" operators.

First, it provides a heuristic motivation for the theory of separation. The theory of spline convolution is based on the premise that each region begins with a piecewise kernel that is destroyed by operator A. Then, convolution of the pattern is performed with Ak. Since A destroys each area of the kernel, convolution actually matches the boundaries of the kernel area. Thus, for dimension d convolution, Ak is in some sense a (d-1) -dimensional kernel. For example, consider the following kernel:

When this kernel dies, the boundary is the ring at r ₀ caused by the discontinuity of k. The non-zero region of Ak is linear at r ₀ , meaning that the "dimension" is d-1.

This is why the convolution according to the present invention uses a separate kernel. The basic premise for performing two-dimensional convolution according to the present invention is that the two-dimensional convolution is performed by factoring the split-kernel. These convolutions do not depend on radius, and in practice this technique drastically reduces the number of convolution operations.             

Suppose we have a two-dimensional kernel k (x, y) that can be expressed as

k (x, y) = k _x (x) k _y (y)

If so, for a given pattern p, the result of the convolution can be expressed as follows.

는 k_y 와 p 의 열-대-열 컨볼루션이다. 본 발명에 따른 컨볼루션 결과를 얻기 위해, p_y(y, j) 를 결정한 다음, 이를 k_x 로 행을 따라 컨볼루션한다. 다음의 일례가 나타내는 바와 같이, 이러한 컨볼루션은 픽셀당 단지 몇 개의 연산이라는 것이 특징이다.But,

Is the column-to-row convolution of k _y and p. To obtain a convolution result according to the invention, p _y (y, j) is determined and then convolved along the row with k _x . As the following example shows, this convolution is characterized by only a few operations per pixel.

The following are two examples of separate-spline convolutions implemented in accordance with the present invention. These examples were chosen to introduce spline techniques for polynomials, Laplacian, and trigonometric functions.

Example 1 Secondary Formula Using Laplacian Attenuated Isolated Kernel

The one-dimensional kernel for this algorithm is defined as follows.

It may be assumed that a (b ² -R ² ) = cd ^-R to realize continuity.

The two-dimensional kernel is defined as in Equation 1 below.

k (x, y) = k ₁ (x) k ₁ (y)

인) 2 개의 감쇠 영역은 상이한 컨볼루션에 의해 각각 발생되며, 이들의 결과는 함께 가산되어 최종 결과가 획득된다.Each one-dimensional convolution is performed in three parts. (| X | ≤ R) cap and (

Two attenuation regions are each generated by different convolutions, the results of which are added together to obtain a final result.

One-dimensional cap convolution is performed using the following kernel.

Choose the destructive operator A _c of the form

(In this case e, f, g, h, i, j, m and n are integers)

At properly selected values of e, f, g, h, i, j, m and n, A _c K _c (x) is zero except for a few specific values of the parameter x. Therefore, to calculate (A _c K _c × p) for each value of x, only a few additions (a smaller number of additions near the boundary of the interval where the convolution is performed) need to be calculated. After calculating (A _c K _c × p) (x) for each value of x, the regression relationship is used to calculate A _c ^-1 (A _c K _c × p) (x) = r (x) . In a typical implementation, a few initial values of A _c ^-1 (A _c K _c × p) (x) are found by direct calculations that "ignite" the calculation of the regression relationship.

Consider the case where the parameters "a" and "b" of K _c (x) satisfy a = 1 and b = R. In this case, the destructive operator A _c is selected as follows.

For such an operator A _c , A _c K _c (x) is zero except for the four x values of x = -2R + 1, x = 2R + 1, x = -2R-1, and x = 2R-1 Becomes Therefore, to calculate (A _c k _c xp) (x) for each value of x, only seven additions (less additions near the boundary of the section where the convolution is performed) need to be calculated. The regression relationship used to calculate A _c ^-1 (A _c k _c xp) (x) = r (x) rewrites A _c defined in the following equation and recursively to x Determined by releasing.

The final difficulty is that we need three k _c initial values to do this. There are two solutions to this problem in "lighting" the convolution. First, {r (0), r (1), r (2)} values can be solved by a direct calculation of multiplying 3 (2R-2) times and adding 3 (2R-3) times. Otherwise, r (x) for x less than -R must be zero since these points are beyond the kernel radius deviating from the pattern. Thus, it can be seen that r (-R-2), r (-R-1) and r (-R) are all zero. The convolution can then be ignited by regression to find {r (0), r (1), r (2)}. The latter procedure requires addition of 3 (R + 2) and multiplication of (R + 2), so in this case, the second approach is much more economical. There are other cases where the second approach is less economical than the first approach.

One-dimensional convolution for the positive damping region is performed using the following one-sided Laplacian attenuation kernel,

It is destroyed by the simple destructive operator A ₊ as follows:

A ₊ k ₊ (R) = cd ^-R or A ₊ k ₊ (R) = 0 otherwise. This is a simple pattern transformation and scaling, and the regression can be as simple as:

The interesting thing about this attenuation kernel is that it can be ignited in the domain of the result. That is, we know that r is zero for all x less than R. So, after filling the initial R value to zero, we actually start the spline.

The one-dimensional convolution for the negative damping region is exactly the same as the one-dimensional convolution for the positive damping region, except that the regression must take the opposite direction. K _c and K ₊ convolution can be computed in a single pass of the pointer, but this slows down the algorithm because k ₋ convolution requires a second reversed pass.

The following is one algorithm for implementing the above-described two-dimensional convolution with detachable-spline convolution according to the present invention. To describe the algorithm, the following definition is required. k _-the kernel is

Its destructive operator A _- is

The algorithm takes a pattern p (x, y) as input to (x, y) ∈ D, where D is a rectangular domain of a predetermined size. The algorithm returns r (x, y) = (k × p) (x, y) for all points of D, where k (x, y) is defined in Equation 1 above. In such a case, due to the nature of the Laplacian attenuation, the optimal "constant" describing k depends only on the width and height of D, which may require the size of D to be fixed. The algorithm calculates convolution by processing k (x, y) as follows.

For easier understanding, the algorithm is presented in an unoptimized manner. In the case of floating-point calculations, this can be done with fixed-point numbers, because sudden and confusing behavior can occur during polynomial convolution.

The algorithm "Algorithm for Quadratic with Laplacian decay separated-spline convolution" is as follows.

(a) Loop the rows. For each row, calculate the cap convolution (step iii), the positive attenuation convolution (step ii), and the negative attenuation convolution (step iii) for each row, and for that row, By adding together three convolutions generated in (ii) and (iii) (step iii), the convolution of the row is calculated by k ₁ (x). One iteration of steps (iii), (ii), (iii) and (iii) is performed for each row of the pattern as follows.

(V) Compute k _c convolution:

Calculating an extinct kernel (A _c k _c × p) (x) convolved with the row of the pattern, in which case A _c is as described above; And

If the parameters "a" and "b" of k _c (x) satisfy a = 1 and b = R, then k _c (x + 3) = A _c k _c (x) + k _c (x) + 3k calculating A _c ^-1 (A _c k _c xp) (x, y) using the above regression relationship of _c (x + 2) -3k _c (x + 1);

(Ii) Calculate k ₊ Convolution:

Compute the extinct kernel (A ₊ k ₊ x p) (x) convolved with the row of the pattern, in which case A ₊ is as described above. It can be seen that this is a simple calculation since (A ₊ k ₊ xp) (x, y) = cd ^-R p (xR, y); And

를 이용하여 A₊ ^-1(A₊k₊ ×p)(x, y)) 계산하기;Regression relationship

Calculating A ₊ ^-1 (A ₊ k ₊ x p) (x, y)) using;

delete

(V) k _- Convolution

Compute the extinct kernel (A _- k _- xp) (x) convolved with the row of the pattern, in which case A _- is as described above. It can be seen that this is a simple calculation since (A _- k _- xp) (x, y) = cd ^-R p (x + R, y); And

를 이용하여 끝에서부터 처음으로 회귀하는 것 에 의해, A_- ^-1(A_-k_- ×p)(x, y) 계산하기;Regression relationship

By the one to which the first return from the end ^{_{use, A - -1 (A - k}} - × p) to calculate (x, y);

를 나타내는 데이터 생성하기;(Iii) at the end of the last iteration of step (iii) by adding the results of steps (iii), (ii) and (iii) for that row of patterns

Generating data representative of;

(b) replacing k ₁ x p to generate (k ₁ x p) ^T ;

(c) a non-line of p (k ₁ × p) by repeating step (a) for the rows of ^T, to convolution all columns of k × ₁ p a k _1; And

(d) Substitute the result of step (c) to generate and return r (x, y).

Typically, the pattern p (x, y) is stored in memory before step (a), and each iteration of step (i) is performed on a different row of pattern p (x, y) read from the memory, step (b) storing (k ₁ × p) ^T in memory such that each row of (k ₁ × p) ^T occupies a memory location previously occupied by the corresponding row of p (x, y) It includes.

You can slightly modify the algorithm to increase the speed. For example, in all cases, the algorithm is preferably performed by a processor programmed to compute each extinct convolution and at the same time inflat it. In this way, there is no need to save the destroyed convolution before planarizing it. It is also desirable for both k ₊ and k _c to be calculated in the same pass through the processor. Also, when column-ferrying techniques are used to calculate the cap and positive attenuation region convolution, two complete substitutions are typically unnecessary, and thermal return, negative convolution and addition are all the same loop. Must be part of Also, when using some type of processor to perform the algorithm, the appropriate operations can be the fastest.

As an approximation to Gaussian, since the Laplacian attenuation is e- ^x and Gaussian is e- ^x2 , the above-described embodiment of the convolution according to the present invention depends on the size of the pattern. Thus, the error depends on the size of the domain.

Example 2 Squared Cosine Isolated Kernel

Next, an embodiment is presented for another discrete-spline kernel (“square cosine” discrete kernel), and the convolution method of the present invention using such squared cosine discrete kernel. Since convolution using a square cosine kernel is independent of the order of the pattern, the convolution using a square cosine discrete kernel is faster and clearer than the convolution using a "secondary" kernel using Laplacian attenuation. In addition, the squared cosine kernel allows the most appropriate method for a one-pass row convolution set, and also allows a ferring technique that uses the computations performed on transfer. Since the square cosine kernel is more stable, floating point calculations can be used. This is because, in the case of polynomials, the error is as chaotic as in polynomials, while in the case of square cosine kernels, small errors become small vibration noise. If the pattern is "normal" in a sense, noise is not perceived for any (very small) level of accuracy. The one-dimensional square cosine kernel is defined as

A two-dimensional kernel is defined as in Equation 2 below.

k (x, y) = k ₂ (x) k ₂ (y)

As described above, kernel k ₂ (x) is written as the sum of two kernels. The first of these is:

The other kernel looks like this:

For these two kernels, k ₂ (x) = k _c (x) + k _i (x). The kernel k _i is easily destroyed by a discrete derivative called A _i for the continuity of the notation. The explicit definition of these destructive operators is as follows:

Dissipating cosine k _c is less direct, but in

If you define operator A _c as

It can be seen that k _c is destroyed by A _c . The destructive operator A to use is the "product" of these two operators:

A can be seen to dissipate k ₂ , and since Ak ₂ = A _i × A _c k ₂ , only A _i is acting on something that is extinguished, and this is also true for Ak _i .

The calculation shows the value of the thesis of Ak as follows.

Next, in order to calculate r (x, y) according to the present invention, an algorithm for convolution of k (x, y) determined by the above-described square cosine kernel with the pattern p (x, y) To present.

k ₂ (x) k ₂ (y) = (k _c (x) + k _i (x) (k _c (y) + k _i (y))

This is very similar to the algorithm described above for convolution using the "secondary with Laplacian attenuation" kernel defined above. The algorithm "Algorithm for squared cosine separated-spline convolution" is as follows.

(a) Looping rows. For each row of the pattern p (x, y), calculate the convolution of that row with k ₂ (x). This is done by one-dimensional spline convolution, which includes the following steps:

(Iii) For -R-3 <x <n-1, calculate Ak ₂ (x) × p (x) for each row as follows:

Ak ₂ (x) × p (x) = 2sin ² (π / 2L) (p (x + R) + p (x + R +1))-(p (x -R)-p (x-R + One)); And

(ii) by a regression relationship of r (x + 2) = Ar (x) + (1 + 2cos (π / L)) (r (x + 1)-r (x)) + r (x-1) By finding the r (x) for the row using the relationship r (-R-4) = r (-R-3) = r (-R-2) = 0 to ignite the regression operation. At the end of the last iteration,), generating data representing k ₂ × p;

(b) replacing k ₂ x p to produce (k ₂ xp) ^T ; And

(c) p, not a row of the _{(x, y) (k 2} × p) is repeated in the step (a) for the rows of ^T, k ₂ convolution to all columns of the k ₂ × p.

Preferably, the final step of substituting the result of step (c) is performed to generate r (x, y), and then the processor returns to its initial state.

Typically, the pattern p (x, y) is stored in memory before step (a), and each iteration of step (i) is performed on a different row of pattern p (x, y) read from the memory, step (b) storing (k ₂ xp) ^T in memory such that each row of (k ₂ xp) ^T occupies a storage location previously occupied by the corresponding row of p (x, y) It includes.

어레이에 대한 전체 알고리즘은,The pure number of calculations for the algorithm described above may include h iterations of step (a), where h is the height; The Ak calculation associated with one multiplication and three additions is performed w + R + three times (w is width); Regression requiring one multiplication and four additions is performed w + R + three times (w is the width). Thus, squared

The entire algorithm for an array is

의 승산과

With the odds of

의 가산을 요한다.

Requires addition.

를 계산할 수 있다. 이는

의 승산을 절감함으로써, 계산 비용을 현저하게 감소시킨다. 두번째는, 모든 승산이 동일하게 고정된 2 개의 숫자에 의한 것이어서, 이것이 최적으로 하드-코딩될 수 있는 것이다. 가장 중요한 세번째는, 이러한 프로세스가 행에 대해 독자적으로 작용하기 때문에, 이것이 매우 용이하게 병렬화 및 벡터화될 수 있다는 것이다. 가산의 횟수도 감소될 수 있지만, 이는 계산 시간에 그다지 영향을 미치지 않는다.This can be optimized in two ways. First, one thing is normalized in the last stage, as p (x + R) + p (x + R + 1)-(p (x-R) -p (x-R + 1))

Can be calculated. this is

By reducing the multiplication, the computational cost is significantly reduced. The second is that all multiplications are by two numbers that are equally fixed, so that this can be optimally hard-coded. The third and most important is that this process can be parallelized and vectorized very easily since it works on rows independently. The number of additions can also be reduced, but this does not affect the computation time very much.

More generally, in the classification of the preferred embodiment, perform convolution r = Dp = d × p (x represents convolution, d is well approximated by the split-spline kernel or is the same as the split-spline kernel) The method of the present invention,

(a) k (x ₁ , ..., x _n ) = k ₁ (x ₁ ) k ₂ (x ₂ ) ... k _n (x _n ) (in this case, k is the operator A = A ₁ A ₂ ... Allows _n , where n is the dimension of pattern p, and A _j is (if A _j is a destructive operator) A _j K _j = B _j is sparse (if A _j is a flattening operator) A specifying a separate-spline kernel as an extinction or flattening operator that acts on the rotation K _j of kernel k _j in such a way that _j K _j = B _j is a local constant matrix almost everywhere;

(b) calculating q ₁ = B ₁ p = A ₁ k ₁ × p for each row of the pattern p;

(c) performing a preliminary ignition step of directly calculating a small number of r ₁ components, and then determining the remainder of the r ₁ components using the natural regression relationship determined by operator A ₁ . Resolving A ₁ r ₁ = q ₁ for each of said rows of the pattern backwards to determine r ₁ = k ₁ × p;

(d) substituting r ₁ = k ₁ × p generated in step (c) to generate r ₁ ^T = (k ₁ × p) ^T for the pattern, and for each row of (k ₁ × p) ^T calculating q ₂ = B ₂ r ₁ ^T = A ₂ k ₂ x (k ₁ xp) ^T ; And

(e) inverting A ₂ r ^T = q ₂ for each row of (k ₁ × p) ^T backwards to determine r ₂ ^T = (k ₂ × k ₁ × p) ^T for the pattern do.

If the pattern p is two-dimensional (n = 2), the result of step (e) is typically substituted to generate data representing r = (k ₂ x k ₁ x p), where the result r is It is an approximation close to the predetermined convolution Dp. If n> 2, steps (d) and (e) are repeated for each additional dimension of the pattern p (by a substitution operator as defined in the above summary), and the substitution for the last iteration result of step (e) Is an approximation (or exactly the same) as a given convolution Dp.

In some implementations of step (c), the fewest lowest components of r ₁ are calculated directly during the preliminary ignition step, and then the remainder of the r ₁ components is determined using the natural regression relationship. In a preferred implementation of step (c), the few large negative components of r ₁ are calculated directly during the preliminary ignition stage, and then the remainder of the r ₁ components is determined using the natural regression relationship.

If the kernel d itself is a split-spline kernel (and therefore d = k and K = D), this method yields the correct result (r = Dp). Otherwise, the error inherent in this method is (k-d) x p, which is easily limited.

An example of working source code (in C language) for a function implementing a separate-spline technique for convolution according to the present invention is as follows. The kernel specified in one example is the square cosine kernel described above. These functions are called by sending pointers to input patterns (* Pattern), output arrays (* Result), and one-dimensional working buffers (* r). Global variables are the array size (where NX × NY) and N = max (NX, NY). This code is optimized to run in minimal memory using several logical clauses. The disadvantage of this is that the simplicity of the algorithm is not obvious at first. Most of the code is a minor variation on the following lines:

The actual algorithm is conceptually very compact.

Example: Source Code of C Implementing Squared Cosine Isolated-Spline Convolution:

In some two-dimensional implementations of the method of the present invention, discrete convolution is performed using a matrix format, whereby the two-dimensional pixel rectangle is one-dimensional using pre-lexicographical indexing. Is converted to a column vector of. In this case, the rotation matrix F becomes a bizarre form of NN '× NN', but when the destructive operator A is applied, the operator AF becomes sparse. This classification for embodiments of the present invention has the advantage of converting nonvanishing circular regions into deterministically-indexed matrix components.

1 is a block diagram of a computer system embodying the present invention. The system includes a processor 2 (programmed in software for implementing any embodiment of the convolution method of the present invention), a display device 4 coupled to the processor 2, an input device 6, and Memory 8 (and optional output device 5 also). If the processor 2 is a conventional processor configured to process binary data, the processor 2 is programmed with software to implement a "discrete" implementation for the method of the present invention. Typically, memory 8 contains data representing rotation D of convolution kernel d, spline kernel k (x ₁ , x ₂ , ..., x _n ) = k ₁ (x ₁ ) k ₁ (x ₂ ). k. Rotation K ₁ for factor kernel k ₁ of k _n (x _n ), the pattern p to be convolved, the intermediate values generated during the performance of the method, and the convolved signal r = Kp resulting from the convolution Save the data. In some implementations, processor 2 may determine that spline kernel k (from the user-specific convolution kernel d of interest) allows spline kernel to approximate convolution kernel d (related to user-specific constraints). It is programmed to determine the parameters. In some implementations, processor 2 generates one or more look-up tables, stores them in memory 8 (or cache memory associated with processor 2), and then stores them while performing the present invention. Access the look-up table. The user controls the processor 2 using the input device 6 (including by specifying processing parameters or restrictions). Text and images generated by the processor 2 (such as the representation of the two-dimensional pattern p to be convolved and the convolution result Kp generated according to the invention) are displayed on the display device 4. The output device 5 (which may be used in place of or in addition to the display device 4) may be a sound reproduction unit, an input / output port, or a signal processing (and / or storage) device ( Or pattern-capable device).

2 is a block diagram of a lithographic system including a digital signal processor (“DSP”) 10 configured to perform convolution (according to the invention) on image data stored in memory unit 14. The image data stored in the memory unit 14 determines the pattern p to be convolved. DSP 10 processes the image data to generate output data representing the convolution result r = Kp. The output data is stored in the memory 14 and / or output to the " pattern signal " generating device 16 (and optionally via further processing). Apparatus 16 is a pattern signal (e.g., an optical beam or other electromagnetic radiation whose amplitude varies with time, or an electron whose amplitude varies with time, in response to data received by DSP 16 from DSP 10). Beams).

In a class of embodiments, the device 16 emits a beam of optical radiation that is incident on the optical system 18 and projects an output beam onto the lithographic target 20. The optical system 18 scans the output beam on the lithographic target 20 in response to the scanning control signal from the control unit 12. The amplitude of the beam emitted from the device 16 is determined in such a way that the scanned output beam (in response to the output data from the DSP 10) (output of the optical system 18) exposes the target 20 to a pattern of pixels. It changes as a function of time (assuming the scanning pattern is determined by the scanning control signal from unit 12).

In another embodiment, the device 16 emits an electron beam that is incident on the optical system 18 and projects an output electron beam onto the lithographic target 20. The optical system 18 scans the output electron beam on the lithographic target 20 in response to the scanning control signal from the control unit 12. The amplitude of the electron beam emitted from the device 16 is determined in such a way that the scanned output beam from the optical system 18 exposes the target 20 to the pattern of pixels (the scanning pattern is applied to the scanning control signal from the unit 12). In response to output data from the DSP 10, which is assumed to be determined by

Alternatively, the device 16 emits the focused radiation (without scanning) on the target 20 by the optical system 18 to determine a pattern and project an image made of pixels. For example, one embodiment of the apparatus 16 allows the optical system 18 to project as a pattern on the target 20 from the optical system 18 without the need for the optical system 18 to scan any beam onto the target 20. To emit optical radiation focused.

The output of the device 16 is called a “pattern signal”, and examples of such a pattern signal include other radiation or optical beams to be scanned by the optical system 18, an electron beam to be scanned by the optical system 18, and the optical system 18. Radiation that is not scanned but is focused by it. Optics 18 may be a set of reflective and / or refractive optics (with or without scanning functionality including means for moving one or more elements of the optics to scan the beam to the target 20) 20) electron beam optics (with a scanning function) comprising means for moving one or more elements of the optics to scan the beam. The output of the optical system 18 is projected (including, for example, by scanning) as a pattern on the lithographic target 20.

Typically, the target 20 is a glass plate or semiconductor wafer (where the projection of the pattern produces a mask useful for the fabrication of integrated circuits). Optical system 18 typically focuses a pattern signal, so that a very small pattern is projected onto target 20.

The “raw” pattern signal output from the device 16 determines the pattern, but the diffraction product introduced by the optical system 18 (or inherent in the interaction between the imaging beam and the target 20) (or Other products) may cause the pattern actually generated on the target 20 to be different from this pattern. For example, the "original" pattern signal output from the device 16 is the electron beam to be focused by the electron beam optics 18 and is determined by the amplitude of the focused electron beam incident on each single pixel of the sequence. In an attempt to project the pattern onto target 20, assume that a sequence of pixels on target 20 is scanned. In this case, the well-known "proximity problem" (described above) exposes the area surrounding each pixel to which the focused electron beam is incident (due to scattering of electrons away from each of these pixels into the surrounding area of the target). Thus, when the multi-pixel region is exposed each time the focused electron beam is incident on one of the pixels of the sequence, the pattern actually formed on the target 20 emits an electron beam focused on each pixel of the sequence. It is determined by the overlap of one result.

Thus, the DSP 10 is configured to generate output data that enables the device 16 to output a " original " pattern signal having the characteristics necessary to generate a predetermined pattern on the target 20. FIG. In order to realize this, the DSP 10 may be any product expected to be introduced by the optical system 18 and / or any expected (eg target) of the electron beam incident on the target 20 from the optical system 18. 20) perform a deconvolution operation on the large array of pixels (image data stored in memory 14) to compensate for any scattering. The deconvolution operation performed by the DSP 10 includes a convolution operation (performed in accordance with the present invention) on the stored image data that the DSP 10 retrieves from the memory 14, in which case the image data Conversely determines a very large array of pixels that determines the pattern "p". Thus, the DSP 10 processes the image data according to the present invention to generate data representing the convolution result r = Kp. The latter data is then further processed before being applied to or applied to device 16.

Controller 12 of the FIG. 2 system applies appropriate control signals to units 10, 14, 16, and 18, and in order to allow DSP 10 to execute convolution operations with certain parameters (e.g., 10) You can download the command.

3 is a block diagram of a digital signal processor that may be used with the DSP 10 of FIG. 2, configured to perform convolution according to the present invention on image data. The DSP of FIG. 3 is arithmetic computational unit (ACU) 34 that includes add and multiply circuits (to perform matrix multiplication and regression arithmetic operations necessary to implement convolution) that are connected as shown. Program memory 30), a program control unit (PCU) 32, a memory management unit 36, and a data memory 38 that store instructions executed by the DSP to perform. In response to a command from the user, the controller 12 of FIG. 2 loads the appropriate command into the memory 30, and the data representing the pattern p (data labeled “INPUT” in FIG. 3) is transferred to the memory 38. Loaded.

PCU 32 is a fetch circuitry that fetches a sequence of instructions from program memory 30, instruction decoding circuitry, and decode circuitry to apply to unit 36 and / or unit 34 at appropriate times. It contains a register that stores the control bits generated by.

The memory management unit 36 generates an address signal in response to the control bits from the PCU 32 (each of which identifies a storage location in the memory 38 to write data to or read data from) and generates this address signal. And to apply to memory 38 via an address bus. Thus, in response to the control bits from PCU 32 (generated in PCU 32 by decoding instructions from program memory 30), unit 36 applies an address signal to data memory 38. .

In response to the address applied by the memory management unit 36, the data memory 38 transmits a signal representing the data to the ACU 34 (via the data bus). The resulting output signal from the ACU 34 (representing the partially processed data or the final convolution result r = k × p) is determined by the address applied by the unit 36 to the memory 38. For storage at the memory 38 location, it may be propagated through the data bus to the memory 38. In some implementations, the memory 38 functions as an I / O buffer for the DSP, and data representing the final convolution result is output from the memory 38 to the pattern signal generator 16 (as output data “OUTPUT1”). In another implementation, data representing the final convolution result is applied directly (or through a buffer) to the pattern signal generator 16 (as output data “OUTPUT2”) from the ACU 34.

4 is a variant of the system of FIG. 2, in which the elements 16, 18 and 20 are identical to the elements of FIG. 2 with the same numbers. In the embodiment of FIG. 4, element 46 is (in accordance with any embodiment of the present invention) for image data (determining the pattern p to be convolved) that element 46 receives from memory unit 44. Configured to perform convolution. (Digital signal processor comprising digital signal processing circuitry configured to perform convolution on data in accordance with any embodiment of the method of the present invention, convolution on data in accordance with any embodiment of the method of the present invention. A device (which may be a commercial or dedicated electronic circuit configured to perform the following, or a programmable gate array-based computing system configured to perform convolution on data in accordance with any embodiment of the method of the present invention). ) Processes the image data to produce output data representing the convolution result r = Kp. The output data is directly applied from the DSP to the pattern signal generator 16, which generates the pattern signal in response to the extraction data from the element 46. The controller 42 of the FIG. 4 system applies the appropriate control signal to the elements 44, 46, 16 and 18, in order to allow the element 46 to execute a convolution operation with certain parameters (e.g., You can download the command at (46).

It is assumed that the DSP of FIG. 3 can implement any embodiment for the method of the present invention. At the end of the convolution operation, processed data representing the convolution result r = Kp is generated. This data may be applied directly to the device 16, or further processed (eg, in unit 34) and then applied to the device 16 or the memory 14.

In view of the following, if the convolution kernel ("d") is sufficiently smoothed so that it can be appropriately approximated by a separate-spline kernel ("k"), the method of the present invention may be adapted to any convolution (r = d × p). ) Can be implemented. If the error ((k-d) x p) inherent in the method is within an acceptable range, the kernel "d" is appropriately approximated by the separate-spline kernel "k". Typically, the convolution kernel "d" used in the field of electron beam lithography proximity error correction is sufficiently smoothed to be properly approximated by the separate-spline kernel "k". As encountered in cryptography, noisy (arbitrary) convolution kernels are typically not smoothed enough to be adequately approximated by a separate-spline kernel "k".

5 is a simplified front view of a computer-readable storage medium 50 (which is a CD-ROM) that stores computer-executable instructions (software). These instructions, in response to the execution of the instructions, cause the computer to perform an embodiment of the method according to the invention.

While the invention has been described in connection with certain preferred embodiments, it will be appreciated that the invention in accordance with the claims should not be unduly limited to such specific embodiments. For example, in some embodiments, the present invention is implemented by hardwired circuitry (eg, commercial or dedicated electronic circuitry) or FPGA systems, or by systems including DSPs.

Claims (36)

Convolutional result r = Dp = d × p (D is a circular kernel d) with at least approximately the same smooth kernel d as the discrete-spline kernel to generate data representing n-dimensions (n is greater than 1) ) Method for convolution of the pattern p (x ₁ , ..., x _n ) (a) specifying the discrete-spline kernel as k (x ₁ , ..., x _n ) = k ₁ (x ₁ ) ... k _n (x _n ), where k _j is the rotation K _j Where k (x ₁ , ..., x _n ) accepts operators A = A ₁ A ₂ ... A _n , where A _j is A _j K (if A _j is a destructive operator). _j is rare (sparse) becomes (if a _j is a flattened operator) a _j K _j is such that the local constant matrix almost everywhere, extinction acting on the rotation K _j of the kernel k _j screen or planarization operator); (b) generating an additional data to process the kernel data representing the pattern data and the kernel k ₁ represents the pattern p, q ₁ = A ₁ represents the k × ₁ p for each row of the pattern p; (c) performing a preliminary ignition step of directly calculating a few r ₁ components and then determining all of the remainder of the r ₁ components using the natural regression relationship determined by the operator A ₁ , thereby determining the angle of the pattern. Processing the additional data to solve backwards A ₁ r ₁ = q ₁ for a row to determine data representing r ₁ = k ₁ × p for the pattern; (d) r ₁ = processes the data representing the _{k 1 × p, (k 1} × p) q 2 = A 2 k 2 × for each line of ^T (k ₁ × p) for producing data representing the ^T Step, where r ₁ ^T = (k ₁ × p) ^T represents the transposition of r ₁ ; And (e) for the pattern p by processing data representing q ₂ = A ₂ k ₂ xr ₁ ^T to solve backwards A ₂ r ₂ ^T = q ₂ for each row of (k ₁ × p) ^T r ₂ ^T = (k ₂ x k ₁ x p) determining the data representing ^T. The method of claim 1, n = 2, Step (e) performs a substitution on the data representing r ₂ ^T = (k ₂ × k ₁ × p) ^{T so} that r = (k ₂ × k ₁ × p) for the pattern, where r is Generating data representing an approximation to convolution Dp). The method of claim 2, (f) generating a pattern signal in response to convolved image data determined at least in part by data representing r = (k ₂ x k ₁ x p) for the pattern; And (g) injecting the pattern signal into a set of optical systems and projecting a pattern image from the optical system onto a lithographic target in response to the pattern signal. The method of claim 3, wherein And the pattern signal is an optical signal. The method of claim 3, wherein And the pattern signal is an electron beam signal. The method of claim 3, wherein And the convolved image data used in step (f) is data representing r = (k ₂ x k ₁ x p) for the pattern. The method of claim 1, n is greater than 2 (f) determining the data representing r ₂ ^T = (k ₂ × k ₁ × p) ^T for the pattern, and then performing j iterations of steps (d) and (e), During the i-th iteration of steps (d) and (e), where i is a positive integer and j = (n-2), q _{i + 2} = A _{i + 2} k _{i + 2} × q _{i + 1} and r _{i + 2} ^T = (k _{i + 2} x k _{i + 1} x ... x k ₁ x p) Data representing ^T is generated. The method of claim 1, The pattern data is stored in a storage location in the memory before step (b), Step (d) is (i) the data representing r ₁ = k ₁ × p so that the data representing each column of (k ₁ × p) occupies the row of the storage position previously occupied by the pattern data representing the row of p; Storing in; And _{(ii) (k 1 × p} ) for each line of ^{_{T q 2 = A 2 k 2}} × (k 1 × p) for generating data indicative of ^T, from one said row of said memory location (k ₁ p × a method of performing, convolution including the step of reading out the data indicative of the heat of). Convolution of the two-dimensional pattern p (x, y) with at least approximately the same smooth kernel d as the discrete-spline kernel to produce data representing r = Dp = d × p where D is the rotation of d. As a method of performing a solution, (a) specifying the discrete-spline kernel as k (x, y) = k ₁ (x) k ₁ (y), wherein

K ₁ (x) satisfies

k _c (x) is the kernel

k ₊ (x) is the one-sided Laplacian kernel,

k _- (x) has the following Laplacian kernel of the same short-side, said specifying step;

(b) processing pattern data representing the pattern p, and kernel data representing the kernel k _c , the kernel k ₊ and the kernel k ₋ , to generate a cap convolution k _c × p (x for each row of the pattern p; ), Generating additional data representing a second convolution k ₊ x p (x) for each row, and a third convolution k _- x p (x) for each row, Additional data representing cap convolution, the second convolution, and the third convolution are added together to q ₁ = k ₁ × p (x, y) = (k _c × p (x, y)) + (k Generating data representing ₊ x p (x, y)) + (k _- x p (x, y)), The data representing the cap convolution is, for each row, A _c k _c × p (x) (where A _c is

Compute the destructive operator defined as

Using the regression relationship of

Generated by calculating The data representing the second convolution is A ₊ k ₊ x p (x) for each row, where A ₊ is

Compute the destructive operator defined as

Using the regression relationship of

Is calculated by The data representing the third convolution is, for each row, A _- k _- x p (x) (where A _- is

Compute the destructive operator defined as

By regression from end to beginning using the regression relationship of

Generated by calculating a; _{(c) (k 1 × p} (x, y)) by substituting the data _{(k 1 × p (x,} y)) represents the step of generating data representative of the ^T; And (d) repeating step (b) by using the kernel data to process data representing (k ₁ x p (x, y)) ^T , not the pattern data, thereby q ₁ ^T = (k ₁ ( x) generating data representing xk ₁ (y) xp (x, y)) ^T. The method of claim 9, The pattern data is stored in a storage location in the memory before step (b), Step (c) is performed such that the data representing each column of (k ₁ × p) occupies a row of the storage position previously occupied by the pattern data representing a row of p (x, y), (k ₁ × storing data representing p) in the memory. The method of claim 9, (e) substituting data representing q ₁ ^T = (k ₁ × k ₁ × p) ^T to generate data representing r = k × p. The method of claim 11, (f) generating a pattern signal in response to convolved image data at least partially determined by data representing r = k × p; And (g) injecting the pattern signal into a set of optical systems and projecting a pattern image from the optical system onto a lithographic target in response to the pattern signal. The method of claim 12, And the pattern signal is an optical signal. The method of claim 12, And the pattern signal is an electron beam signal. Two-dimensional pattern p (x, y with at least approximately the same smooth kernel d as the detachable kernel to produce data representing convolutional results r (x, y) = Dp = d × p (where D is a rotation of d) A method of performing convolution of (a) specifying k (x, y) = k ₂ (x) k ₂ (y) using k (x, y) approximating the kernel d, where:

Phosphorous, said specific step; (b) processing the pattern data representing each row of the pattern p and the kernel data representing the kernel k ₂ , (i) for -R-3 &lt; = x &lt; n-1, generating data representing Ak ₂ × p for each row: Where Ak ₂ (x) × p (x) = B (p (x + R) + p (x + R + 1) −p (x−R) −p (x−R + 1))); And (ii) regression relationship r (x + 2) = Ar (x) + B (r, to find r (x) = A ^-1 (Ak ₂ (x) x p (x)) for each of the above rows Use (x + 1)-r (x)) + r (x-1) and fire a regression operation: r (-R-4) = r (-R-3) = r (-R-2 Performing the regression operation with 0) to generate data representing k ₂ x p at the end of the last iteration of step (ii); (c) by substituting the data representing the _{k 2 × p (k 2 ×} p) generating data representative of the ^T; And (d) for producing data representing a convolution of all the columns of by repeating the step (b) for the line of data indicating non-line (k ₂ × p) ^T of the pattern data, k ₂ × p by k ₂ And a step of performing a convolution. The method of claim 15, Steps (b), (c) and (d) are performed by a programmed processor, The processor is in an initial state at the beginning of step (b), After step (d), the processor (e) by substituting the data that represents the convolution of all the columns of ₂ k × ₂ k p to the convolution result to produce data representative of the r (x, y); And (f) after step (e), performing an additional step of returning to the initial processor state. The method of claim 16, (g) generating a pattern signal in response to convolutional image data at least partially determined by data representing the convolution result r (x, y); And (g) injecting the pattern signal into a set of optical systems and projecting a pattern image from the optical system onto a lithographic target in response to the pattern signal. The method of claim 17, And the pattern signal is an optical signal. The method of claim 17, And the pattern signal is an electron beam signal. The method of claim 15, The pattern data is stored in a storage location in the memory before step (b), Step (c), p (x, y), said pattern data representing a line of a so as to occupy the data representing each column of a row of the storage position occupied previously _{(k 2 × p) k 2} × p And storing the data indicative in the memory. The method of claim 15, A method of performing convolution, wherein B = 2sin ² (π / 2L). The method of claim 15, Method of performing convolution, with B = 1. Processing second data representing a discrete-spline kernel k (x ₁ , ..., x _n ) = k ₁ (x ₁ ) ... k _n (x _n ) approximating d using the first data Generate third data representing q ₁ = A ₁ k ₁ × p for each row of pattern p (where k _j has rotation K _j and kernel k (x ₁ , ..., x _n ) operator, and a = a ₁ a ₂ ... a _n permit, a _j is (a _j is destroyed screen when the operator) a _j K _j is the rare and (in the case of a _j are flattened operator) a _j K _j is such that the local constant matrix almost everywhere, kernel extinction acting on the rotation K _j screen or planarization operator responsibility of the k _j), to pay a a ₁ r ₁ = q ₁ for each row of the pattern released backwards and by processing the third data to determine the fourth data representative of the r ₁ = k ₁ × p with respect to the pattern, and processing the fourth data (k ₁ × p) q for each line of ^T = ₂ Generates fifth data representing A ₂ k ₂ × (k ₁ × p) ^T , where r ₁ ^T = (k ₁ × p) ^T represents a substitution of r ₁ , (k ₁ × p) ^T Processing the fifth data to solve A ₂ r ^T = q ₂ backwards for each of the rows of to determine the sixth data representing r ₂ ^T = (k ₂ x k ₁ x p) ^T for the pattern Thereby convolving first data representing an n-dimensional pattern p (x ₁ , ..., x _n ) (where n is greater than 1) to at least approximately the same smooth kernel d as the detached-spline kernel. A software programmed processor that generates data indicative of the solution result r = Dp = d × p where D is a rotation of d; One or more memories coupled to the processor and accessible by the processor and configured to store at least the first data, the second data and the fifth data; And An input device coupled to the processor, And the processor to execute the software in response to one or more control signals from the input device. The method of claim 23, n = 2, The software causes the processor to perform substitution on the sixth data to generate seventh data representing r = (k ₂ x k ₁ x p) for the pattern, And the seventh data is data representing the convolution result r = Dp = d × p. First data representing an _n -dimensional pattern p (x ₁ , ..., x _n ) and a split-spline kernel k (x ₁ , ..., x _n ) = k ₁ (x ₁ ) ... k A digital signal processing circuit configured to perform an arithmetic operation on data including second data representing _n (x _n ), wherein k _j has a rotation K _j and kernel k (x ₁ , ..., x _n ) the operator a = a and allow _{1 a 2 ... a n, a} j is (a _j is extinguished when the screen operator) a _j K _j is the rare and (in the case of a _j are flattened operator) a _j Is an extinction or flattening operator acting on the rotation K _j of kernel k _j such that K _j is a local constant matrix almost everywhere, and the kernel k is at least approximately equal to the smooth kernel d with rotation D, n is greater than 1, wherein the digital signal processing circuit; And Processing the first data and the second data to generate third data representing q ₁ = A ₁ k ₁ × p for each row of the pattern p, wherein A ₁ r ₁ for each row of the pattern = by the q ₁ naedorok released backwards by processing the third data determine the fourth data representative of the r ₁ = k ₁ × p with respect to the pattern, and processing the fourth data (k ₁ × p) each of ^T Generate fifth data representing q ₂ = A ₂ k ₂ × (k ₁ × p) ^T for a row, where r ₁ ^T = (k ₁ × p) ^T represents a substitution of r ₁ , ( k ₁ × p) ^T the by a ₂ r ₂ naedorok inverted releasing ^T = q processing said fifth data for each row r ₂ ^T = to said pattern (k ₂ × k ₁ × p a) showing a ^T By determining a sixth data, generate a control bit in response to a command and convert the control bit into the digital signal processing. And a program control unit, applied to the circuit, the digital signal processing circuit configured to perform convolution on the first data, the program control unit being coupled to the digital signal processing circuit. The method of claim 25, n = 2, And the control bit causes the digital processing circuit to perform substitution for the sixth data to generate seventh data representing r = (k ₂ x k ₁ x p) for the pattern. A digital signal processor having a digital signal processing circuit and a program control unit coupled to the digital signal processing circuit, the digital signal processing circuit responsive to control bits from the program control unit, wherein the n-dimensional pattern p (x) _First data representing ₁ , ..., x _n ) and second representing spline kernel k (x ₁ , ..., x _n ) = k ₁ (x ₁ ) ... k _n (x _n ) Perform an arithmetic operation on data containing 2 data, where k _j has rotation K _j and kernel k (x ₁ , ..., x _n ) is operator A = A ₁ A ₂ ... A _n to allow and, a _j is (a _j is destroyed screen when the operator) a _j K _j is rare (sparse) and (a _j is the case of the flattening operator) a _j K _j is locally constant almost everywhere Chemistry and extinction or planarization operator acting on the rotation of the kernel k _j so that the matrix K _j, the spline Channel k is the same as smoothing kernel d having a rotation D, at least in approximation, n is 1 greater than), q ₁ for the processing of the second data with the first data on each line of the pattern p = A ₁ generate third data representing k ₁ × p and process the third data to solve A ₁ r ₁ = q ₁ backwards for each row of the pattern, thereby generating r ₁ = k ₁ × p to determine the fourth data indicating, and process the fourth data _{(k 1 × p) q 2} = a 2 k 2 × for each line of ^T (k ₁ × p) generating a fifth data indicative of a ^T and ^{_{(wherein, r 1 T = (k 1}} × p) T is r represents the substitution of the _{1), (k 1 × p} ) T wherein a ₂ r ₂ ^T = q naedorok the loose upside-down wherein for each row of the 5 by processing the data to determine a sixth data indicative of the ^{_{r 2 T = (k 2 ×}} k 1 × p) T with respect to the pattern for the sixth data The digital signal processor configured to perform convolution on the first data by performing substitution to generate seventh data representing r ₂ = (k ₂ × k ₁ × p) for the pattern; A pattern signal generator configured to generate a pattern signal in response to the convolved image data determined at least in part by the seventh data; And A set of optical systems positioned such that said pattern signal is incident thereon, And the optical system projects a pattern image onto the lithographic target in response to the pattern signal. The method of claim 27, The digital signal processor applies the seventh data to the pattern signal generator, And the pattern signal generator is configured to generate the pattern signal in response to the seventh data. The method of claim 27, And the pattern signal is an optical signal. The method of claim 29, The optical signal is an optical beam, The set of optics is configured to focus the optical beam to generate a focused beam and to scan the focused beam against the lithographic target. The method of claim 27, And the pattern signal is an electron beam signal. The method of claim 31, wherein The set of optics is configured to focus the electron beam signal to generate a focused electron beam and to scan the focused electron beam against the lithographic target. The first signal representing the _n -dimensional pattern p (x ₁ , ..., x _n ) is a split-spline kernel k (x ₁ , ..., x _n ) approximating the smoothing kernel d = k ₁ (x ₁ ) ... convolved with a second signal representing k _n (x _n ), where k _j has rotation K _j and kernel k (x ₁ , ..., x _n ) is operator A = a and allow _{1 a 2 ... a n, a} j is (a _j is destroyed screen when the operator) a _j K _j is the rare and (in the case of a _j are flattened operator) a _j K _j is An extinction or flattening operator acting on the rotation K _j of kernel k _j to be a local constant matrix almost everywhere), q ₁ = A ₁ for each row of pattern p from the first and second signals. generate a third signal representing k ₁ × p and process the third signal to solve A ₁ r ₁ = q ₁ backwards for each row of the pattern, r ₁ = k ₁ × p for the pattern Fourth signal indicating Occurs, and from said fourth _{signal, (k 1 × p) q} 2 = A 2 k 2 × for each line of ^T (k ₁ × p) generating a fifth signal indicative of the ^T, and (wherein, r ₁ ^T = (k ₁ × p) ^T denotes the substitution of _{r 1), (k 1 ×} p) the pattern naedorok inverted releasing the a ₂ r ₂ ^T = q for each of the rows of ^T, by processing said fifth signal By generating a sixth signal representing r ₂ ^T = (k ₂ × k ₁ × p) ^T with respect to the convolutional result r = Dp = d × p (where D is the rotation of d and n is 1 Greater than), And the sixth signal at least approximately represents the convolution result r = Dp. The method of claim 33, wherein And the device comprises an electronic circuit. The method of claim 33, wherein And the device is a programmable gate array-based computing system. A computer-readable storage medium storing instructions The instructions are executable by a computer, The command is In response to execution of the instruction, the computer at least approximately detaches the spline kernel k (x ₁ , ..., the first data representative of the _n -dimensional pattern p (x ₁ ,..., X _n ). x _n ) = k ₁ (x ₁ ) ... convolves with the same smooth kernel d as k _n (x _n ) to produce a data that represents the convolution result r = Dp = d × p ( Where k _j has rotation K _j , kernel k (x ₁ , ..., x _n ) accepts operators A = A ₁ A ₂ ... A _n , where A _j is (A _j is destroyed) Operator _j ) acts on the rotation K _j of kernel k _j such that A _j K _j is sparse (if A _j is a flattening operator) and A _j K _j is a local constant matrix almost everywhere. Is a destructive or flattening operator, D is a rotation of d, and n is greater than 1), The method, Processing second data representing the discrete-spline kernel k (x ₁ , ..., x _n ) = k ₁ (x ₁ ) ... k _n (x _n ) into the first data, thereby Generating third data representing q ₁ = A ₁ k ₁ × p for each row; Processing the third data to solve backwards A ₁ r ₁ = q ₁ for each row of the pattern, to determine fourth data representing r ₁ = k ₁ × p for the pattern; To process the fourth _{data, (k 1 × p) q} 2 = A 2 k 2 × for each line of ^T (k ₁ × p) generating a fifth data indicative of the ^T (where, r ₁ ^T = (k ₁ x p) ^T represents a substitution of r ₁ ); By processing the fifth data to solve A ₂ r ₂ ^T = q ₂ backwards for each row of (k ₁ × p) ^T , r ₂ ^T = (k ₂ × k ₁ × p) for the pattern Determining sixth data representing ^T ; And Performing substitution on the sixth data to generate seventh data representing r = (k ₂ × k ₁ × p) for the pattern, And the seventh data at least approximately represents the convolution result r = Dp.

Images