WO2013082995A1

WO2013082995A1 - Method for decomposing sampling task

Info

Publication number: WO2013082995A1
Application number: PCT/CN2012/084748
Authority: WO
Inventors: 阳赛
Original assignee: Yang Sai
Priority date: 2011-12-06
Filing date: 2012-11-16
Publication date: 2013-06-13
Also published as: CN102496170A

Abstract

The present invention provides a computer image rendering method. According to the method, on the basis of a (t, s) sequence, a sampling task is decomposed through a hierarchical displacement operation. Compared with a method of carrying out grouping on the (t, s) sequence in a selected dimension to decompose a sampling task, in the present invention, grouping is not required to be carried out on sampling points in an additional dimension, and no limited condition exists for a generator matrix of the (t, s) sequence. Therefore, the method can be used for any type of (t, s) sequence and the quality of the sampling points is not influenced by the quantity of parallel processing units.

Description

Description A method for sampling task decomposition

BACKGROUND OF THE INVENTION 1. Field of the Invention The present invention relates to a computer image rendering method, and more particularly to a rendering method for determining a position of a sample point using a quasi-random number. BACKGROUND OF THE INVENTION In the field of computer image rendering, in order to simulate various light and shadow effects, for example, depth of field, motion blur, global illumination, etc., it is necessary to evaluate an integral having the following form: f(x ⁽¹⁾ , x ⁽²⁾ , .. .,x ^(s) )dx ⁽¹⁾ dx ⁽²⁾ ...dx ^(s) ₍₁₎ where / is the unit interval, and the function /(·) is determined by the effect to be simulated and the input scene data. The formula (1) can't be solved exactly. In the actual rendering process, the numerical calculation method is always used to find the approximate value:

The method for determining the position of the sample points (χ, χ^,...,χ in equation (2) can be divided into two categories, one is the method using random numbers, and the other is the method using quasi-random numbers. A random number is a distribution pattern with a good structure, in the formula

The integral estimation of (2) can provide higher efficiency than random numbers.

The {t,s) sequence is a major quasi-random number type. The method for generating the first dimension component of the first point in a hexadecimal (t^) sequence is as follows:

Where C ^j .= (cH:. – is the (_jj) sequence of the _/dimensional generator matrix (generator matrices) whose coefficient e is the element in the finite field F _b . b ή represents the integer in hexadecimal representation The first digit, ie

M-1

i=∑ b _r {i)b ^r . M is the selected maximum precision in hexadecimal notation.

r = 0

[t,s) ;>歹! ό iH ""Pack 4 tongue: Sobol serial number ' j, Faure sequence 歹 ' j, Niederreiter sequence 歹¹ j mouth Niederreiter- Xing sequence. The difference between different (t^) sequences is that the construction methods of their generator matrices are different. The parallel calculation of the specification is another way to improve the efficiency of the formula (2). The method decomposes the function of the function /(·) into two or more parts in the formula (2), and each part is assigned to an independent Parallel processing unit for processing:

among them,

For the number of sample points, D is the number of parallel processing units, and N _d is the number of sample points allocated by the Jth processing unit. The number of sample points allocated by different processing units may be the same or different.

Any quasi-random number can be used directly in equation (2), but it must be used for equation (4).

In order to simultaneously obtain the benefits of using quasi-random numbers and parallel computations, U.S. Patent Application No. 12/432,498, issued November 4, 2010, provides a sequence of (, s) in a selected dimension. A method of grouping to achieve decomposition of a sample task. This method mainly has the following defects:

An additional dimension is required to enable grouping of sample points;

The generator matrix of the sequence used must be reversible, so a sequence of (J) sequences such as Niederreiter-Xing sequences that do not satisfy this condition cannot be used;

In order to obtain the best sample quality, the number of parallel processing units must be the power of the base of the (,) sequence used, ie 3m>0, satisfying D = b ^m , where D is the number of parallel processing units, 6 is ( J) The cardinality of the sequence. When this condition is not met, the quality of the sample will decrease. SUMMARY OF THE INVENTION The present invention provides a computer image rendering method that implements decomposition of a sample task by a hierarchical replacement operation based on a (^) sequence.

A solution for achieving the technical object of the present invention includes the following steps:

(Α) For the integral of the required value when rendering the image f(x ^{l x ^{2 ..., x ^{s) )dx ^{l) dx ^{2) ...dx ^{s) Use the numerical calculation method Its approximation includes the following steps:

Decompose the function /(·) into two or more parts, each part being processed by a separate parallel processing unit

/ / N o where Ν _ά is the number of sample points, D is the number of parallel processing units, and N _d is the Jth processing Explain the number of sample points allocated by the book unit, and the number of sample points allocated by different processing units may be the same or different;

(B) A method of determining the value of the variable described in the step (A), wherein Q ≤ i _{d ≤} N _d — \ , \ ≤ _d ≤ D, including the following steps:

Group ( ), ,..., )) into (χ ), ..., ), ^{+ 1} ), ..., ), ... ^{+ 1} ), · ··, where P. =0 , P _{q + 1} = s , 0<p _v+1 -p _v ≤s _max 0≤v≤q , s is the selected largest dimension; for the variable group ^ ^{ν + 1} ),..., ^ ^ν+1 ) , where 0 ≤ ^{v ≤} g, the method of determining the value includes the following steps:

Its towel,

A matrix is generated for the first dimension of a hexadecimal (^) sequence, indicating that the H-th digit of the integer in hexadecimal notation is i=∑ bi ^r , where Μ is the maximum precision selected in the hexadecimal representation. ; for hierarchical replacement operations, for an integer x=∑ x, b ^r , π _ν {χ):=∑ b; ^{

-=o

Medium

( + mod b

{b _M ( + mod b

( + mod b bo (x) = (b ₀ {x) + ξ _{ν-1> (} mod b where ζ _ν > ζ ζ , Ο, Ο ' · ·· ' ζ ... ' ζ , ≤ V ≤ q , Independent random numbers.

The invention has the following advantages:

Since the present invention is based on sequences, the decomposition of the sample task is achieved by a hierarchical replacement operation, compared to a method of grouping the {t, s) sequences in a selected dimension to achieve decomposition of the sample task. The present invention does not need to group the sample points in an additional dimension, and there is no restriction on the generation matrix of the (t) sequence, and can be applied to any type of (^) sequence, and the quality of the sample points is not parallel. The impact of the number of processing units. BEST MODE FOR CARRYING OUT THE INVENTION Hereinafter, the present invention will be described in detail in conjunction with the embodiments.

Table 1 lists examples of C++ code for calculating binary Niederreiter sequences: Instruction sheet 1

Typedef unsigned int Uint;

Typedef unsigned int32 Uint32;

Typedef unsigned int64 Uint64; typedef Uint32 Code—Type;

#define Max Dimen 12

#define Bit—Count 31

#defme NBits 32 extern const Code—Type Nied2_Table[Max_Dimen] [NBits];

Code—Type nied2 (

Code—Type instance,

Uint i dim)

Code—Type result = 0; for (Uint i = 0; i < NBits; ++i)

Code_Type itemp = instance &Nied2_Table[i_dim][i]; for (Uint k = l ; k < NBits; k «= 1)

Itemp ^A = (itemp » k); result |= (itemp & 1) « (Bit_Count - i); return (result); In the code shown in Table 1, the maximum precision is set to 32 bits. The reason for setting a maximum precision is that in numerical calculations, it is neither possible nor necessary to perform infinitely accurate calculations.

In the code shown in Table 1, the maximum dimension is set to 12 dimensions. The role of setting the maximum dimension is that, on the one hand, the data of the generator matrix needed to calculate the {t , s) sequence needs to be stored in a computer-readable medium in advance, and it is impossible for any device in reality to store an infinite number of On the other hand, although the quality of quasi-random numbers is better than random numbers, as the dimension increases, the quality of quasi-random numbers will gradually decrease, so it is not necessary to use infinite-dimensional quasi-random numbers in practice.

For different sequences, the selection of the largest dimension is based on its quality parameters t and the set maximum precision. The principle is that the quality parameter of the selected largest dimension should not exceed the set maximum precision.

Table 2 lists the quality parameters of the binary Sobol sequence, the Niederreiter sequence, and the Niederreiter-Xing sequence in different dimensions. The smaller the parameter, the higher the quality and the minimum is 0. Instruction sheet 2

As can be seen from the above table, for the binary Sobol sequence and the Niederreiter sequence, if the maximum precision is set to 32 bits, the maximum dimension should be selected as 12 dimensions, because the quality parameters of the 12-dimensional Sobol sequence and the Niederreiter sequence are 31 and respectively. 30, not exceeding 32, and the quality parameters of the 13-dimensional Sobol sequence and the Niederreiter sequence are 35 and 34, respectively, exceeding 32.

To use the ( ^) sequence, you need to set a maximum dimension. When the dimension of the sample point required to render the image exceeds the set value, you need to perform a hierarchical replacement operation on the sequence number of the {t, s) sequence. The sequence number can be used to generate new components for the original (t^) sequence. In addition, this hierarchical replacement operation is also used for the decomposition of the sample task. Table 3 lists examples of C++ code that implements this hierarchical replacement operation:

table 3

Inline Uint64 hash64 (

Uint64 v) v = v* 3935559000370003845ULL + 2691343689449507681ULL; v»21;

v « 37;

ν» 4; v *= 4768777513237032717ULL; v ^Λ = v « 20;

ν ^Λ =ν»41;

ν ^Λ = ν « 5; return (v);

Code—Type hierch_perm (

Code—Type instance,

Uint level)

Uint64 const seed = Uint64(level) « NBits; Code_Type const mask =~Code_Type(0); Code_Type result = instance; Specification for (Uint i = 0; i <Bit-Count; ++i)

Code_Type index = (instance » (i + 1)) + (mask » (i + 1); result ^A = Code_Type(hash64(seed | index) & 1) « i; result ^A = Code_Type(hash64(seed) & 1) « Bit_Count; return (result); Table 4 lists C++ code examples for decomposing a sample task by hierarchical substitution operations based on the binary Niederreiter sequence, which is used in Table 1 and Table The code shown in 3:

Table 4

Struct Context {

Public:

Context();

Code—Type prev;

Code—Type curr;

Uint dim;

Uint level; inline Context: : Context () memset(this, 0, sizeof(*this)); void sampling (

Double result [],

Uint dim,

Context &context)

Uint d = context, dim; for (Uint i = 0; i <dim; ++i) if (d >= Max Dimen) context.curr = hierch_perm(context.prev, context.level++); d = 0; Instruction manual

Code—Type code = nied2(context.curr, d++); result[i] = double(code) I double(lULL « NBits); context.dim = d; void sampling (

Double result [],

Uint dim,

Context &context,

Code_Type index) context.prev = index; context.curr = hierch_perm(index, 0); context.dim = 0; context.level = 1 ; sampling(result, dim, context); void parallel_part (

Uint programlndex,

Uint programCount)

Code—Type i = 0; while (!aborted())

Context context; double t[2]; sampling(t, 2, context, (i++) * programCount + programlndex); Vector dir; generate_dir(dir, t); Color result; raytrace(result, context, dir); Instruction manual

Table 5 lists examples of C++ code that uses the code shown in Table 4 during rendering:

table 5

Void renderer (

Uint programCount) for (Uint i = 0; i < programCount; ++i)

Parallel_part(i, programCount); void shader (

Color &result,

Context const &context)

Context next = context; double t[2]; sampling(t, 2, next);

Vector dir; generate_dir(dir, t); raytrace(result, next, dir); In the code shown in Table 4, the same s) sequence is used for each group of the dimension components of the sample, ie binary Niederreiter sequences, except for the same (t, sequence can also use {t, s) sequences with the same base but different types, for example, the binary Niederreiter-Xing sequence. Although the quality of the Niederreiter-Xing sequence is superior to the Sobol sequence and the Niederreiter sequence, there is a limitation in the use that the total sampling dimension must be determined in advance, and thus is not suitable as a universally applicable method in image rendering, but if currently The grouping dimensions are known and there will be no higher dimensionality, and the Niederreiter-Xing sequence can be used to replace the Niederreiter sequence for better rendering.

An extension of the (t, s) sequence is called a randomized (t) sequence (ranized {t , s) sequences , which is used to estimate the error magnitude of the integral approximation. Although it is not necessary to estimate the error magnitude of the integral approximation when rendering the image, this randomization method can be used to alleviate the flaws in the image in the rendering of the animation, that is, using different random number pairs for different image frames in the animation rendering. Randomize to fade out the possible enamel patterns.

Table 6 lists the C++ code examples with the addition of randomization steps based on the code shown in Table 4:

Table 6

Inline Uint64 random (

Uint64 v) Specification v = v * 3202034522624059733ULL + 4354685564936845319ULL; v ^Λ = v » 11 ;

v ^Λ = v « 29;

ν ^Λ = ν » 14; ν *= 2685821657736338717ULL; ν ^Λ = ν « 30;

ν ^Λ = ν » 35;

ν ^Λ = ν « 13; return (v); void randomized sampling (

Double result[],

Uint dim,

Context &context,

Uint frame)

Uint64 seed = (Uint64(frame) « NBits) +

Context. level * Max Dimen + context.dim; sampling(result, dim, context); for (Uint d = 0; d < dim; ++d)

Code_Type code = Code_Type(result[d] * (1ULL « NBits)); code ^A = (Code_Type)random(seed++); result[d] = double(code) I double(lULL « NBits);

Claims

Claim

A computer image rendering method, comprising: the following steps:

(A) For the integral of the required value when rendering the image f(x ^{l x ^{2 ..., x ^{s) )dx ^{l) dx ^{2) ...dx ^{s) Its approximation includes the following steps:

_D N _d -ld=\ i ==00

a

Where N ^ N _d is the number of sample points, Z) is the number of parallel processing units, and N _d is the first processing d = \

The number of sample points allocated by the unit, the number of sample points allocated by different processing units may be the same or different;

(B) A method of determining the value of the variable ( ^χ ^···^)) in the step (A), wherein Q ≤ i _{d ≤} N _d - 1 , \ ≤ _d ≤ D, including the following steps:

Will be grouped as ( . ^{+ 1} ),..., ), ^{+ 1} ),...^..., ^{+ 1} ), _ ₊₁ )) ,

'ddd ' dddddd where P. =0 , P _{q + l} = s , 0<p _v+l -p _v ≤s _max , 0≤v≤q , s is the selected largest dimension; for the variable group ^ ^{V + 1} ),..., ^ ^V+1 ) , where 0 ≤ v ≤ g, the method of determining the value includes the following steps: χ^ ^{+ Δ)} = Η _Δ (1^) , 0 ≤ _v _{≤ q} , \<Λ ≤ ρ _{ν +} -ρ _ν ; D + d) , 0<ν≤ί7 ;

among them

The hexadecimal ( ^) sequence of the dimension · the generation matrix, representing the integer number in the hexadecimal representation of the H number

M-1

That is, i=∑ i)b ^r , where Μ is the selected maximum precision in hexadecimal representation;

M-1 M-1

^Α') is a hierarchical permutation operation, for an integer x=∑ b _r x ^r , π _ν {χ):=∑ b; ^{{ ]} {x)b ^r ,

=0

Medium

Bo ^] (x) = (b ₀ {x) + ξ _ν _ ( ₄₆ mod b

The claim requires ^ν 1 ... , ≤V≤q to be independent random numbers.

2. The method of claim 1, further comprising using the same (^) sequence or a (^) sequence of the same base but different types for each group of the dimensional components of the sample.

The method according to claim 1, wherein the sequence comprises a Sobol sequence, a Faure sequence, and a Niederreiter sequence mouth Niederreiter-Xing sequence.

4. The method of claim 1, wherein the (t^) sequence further comprises a randomized (t^) sequence.