EP4042299A1 - Module de traitement de données identifiant un fractile d'un jeu de données - Google Patents

Module de traitement de données identifiant un fractile d'un jeu de données

Info

Publication number
EP4042299A1
EP4042299A1 EP20797816.4A EP20797816A EP4042299A1 EP 4042299 A1 EP4042299 A1 EP 4042299A1 EP 20797816 A EP20797816 A EP 20797816A EP 4042299 A1 EP4042299 A1 EP 4042299A1
Authority
EP
European Patent Office
Prior art keywords
data
datum
value
processing module
input
Prior art date
Legal status (The legal status is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the status listed.)
Pending
Application number
EP20797816.4A
Other languages
German (de)
English (en)
Inventor
François Leroy
Current Assignee (The listed assignees may be inaccurate. Google has not performed a legal analysis and makes no representation or warranty as to the accuracy of the list.)
Safran Electronics and Defense SAS
Original Assignee
Safran Electronics and Defense SAS
Priority date (The priority date is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the date listed.)
Filing date
Publication date
Application filed by Safran Electronics and Defense SAS filed Critical Safran Electronics and Defense SAS
Publication of EP4042299A1 publication Critical patent/EP4042299A1/fr
Pending legal-status Critical Current

Links

Classifications

    • G—PHYSICS
    • G06—COMPUTING OR CALCULATING; COUNTING
    • G06F—ELECTRIC DIGITAL DATA PROCESSING
    • G06F17/00—Digital computing or data processing equipment or methods, specially adapted for specific functions
    • G06F17/10—Complex mathematical operations
    • G06F17/18—Complex mathematical operations for evaluating statistical data, e.g. average values, frequency distributions, probability functions, regression analysis
    • G—PHYSICS
    • G06—COMPUTING OR CALCULATING; COUNTING
    • G06F—ELECTRIC DIGITAL DATA PROCESSING
    • G06F7/00—Methods or arrangements for processing data by operating upon the order or content of the data handled
    • G06F7/38—Methods or arrangements for performing computations using exclusively denominational number representation, e.g. using binary, ternary, decimal representation
    • G06F7/48—Methods or arrangements for performing computations using exclusively denominational number representation, e.g. using binary, ternary, decimal representation using non-contact-making devices, e.g. tube, solid state device; using unspecified devices
    • G06F7/50—Adding; Subtracting
    • G06F7/501—Half or full adders, i.e. basic adder cells for one denomination
    • G—PHYSICS
    • G06—COMPUTING OR CALCULATING; COUNTING
    • G06T—IMAGE DATA PROCESSING OR GENERATION, IN GENERAL
    • G06T5/00—Image enhancement or restoration
    • G06T5/20—Image enhancement or restoration using local operators
    • G—PHYSICS
    • G06—COMPUTING OR CALCULATING; COUNTING
    • G06V—IMAGE OR VIDEO RECOGNITION OR UNDERSTANDING
    • G06V10/00—Arrangements for image or video recognition or understanding
    • G06V10/20—Image preprocessing
    • G06V10/30—Noise filtering
    • G—PHYSICS
    • G06—COMPUTING OR CALCULATING; COUNTING
    • G06V—IMAGE OR VIDEO RECOGNITION OR UNDERSTANDING
    • G06V10/00—Arrangements for image or video recognition or understanding
    • G06V10/40—Extraction of image or video features
    • G06V10/50—Extraction of image or video features by performing operations within image blocks; by using histograms, e.g. histogram of oriented gradients [HoG]; by summing image-intensity values; Projection analysis

Definitions

  • TITLE Data processing module identifying a fractile of a data set FIELD OF THE INVENTION
  • the present invention relates to the field of methods and devices for identifying, in a data set, a fractile belonging to a predetermined subset of fractiles, such as a median.
  • Document US 2012/076432 discloses a device for filtering a set of n input data so as to produce an output value.
  • the output value is the median of the respective values of the n input data.
  • the median is a specific fractile that divides the set of n data (when ordered) into two groups of equal sizes.
  • This device comprises several processing units, including a determination unit carrying out a minimum search to determine the median.
  • An aim of the invention is to determine a fractile of a data set in a faster and / or implementable manner on an extremely small area.
  • a module for processing a set of n input data comprising a reference datum, each input datum having a value, each input datum being moreover associated. to a weight
  • the processing module being configured to: a) calculate the sum of the weights associated only with the input data other than the reference datum which have values strictly lower than the value of the reference datum, b) compare the sum calculated in step a) with a first threshold, c) calculate the sum of the weights associated only with the input data other than the reference datum which have values strictly greater than the value of the reference datum, d ) compare the sum calculated in step c) with a second threshold, e) generate an output data indicating whether the reference data is a fractile of the set included in a predetermined subset of fractiles, only if the following two conditions are satisfied: the sum calculated in step a) is less, strictly or not, at the first threshold and the sum calculated in step c) is less, strictly or not
  • the module according to the first aspect can comprise the following characteristics, taken alone or combined with one another when this is technically possible.
  • the output data is a Boolean.
  • the processing module comprises:
  • each first comparator being configured to generate a comparison result between the value of the reference datum and the value of another datum input to the set
  • step a a first adder configured to implement step a) on the basis of the results generated by the first comparators.
  • the processing module comprises:
  • each second comparator being configured to generate a comparison result between the value of the reference datum and the value of another datum input to the set
  • step c) a second adder configured to implement step c) on the basis of results generated by the second comparators.
  • the processing module comprises: two comparators configured to respectively generate two comparison results between the value of the reference datum and the value of another input datum of the set, in which one of the two comparators is configured to be confined to testing an equality between the value of the reference data and the value of the other data input to the set, and the other of the two comparators is configured to limit itself to testing an order relation between the value of the reference datum and the value of the other input datum of the set, the processing module being moreover configured to cross the two results to determine whether the weight of the other value is to be included in the sum calculated in step a) or in the sum calculated in step c).
  • the sum of the first threshold and of the second threshold is equal to s + p, where s is the sum of the weights of the n input data, and where pe [-1, 1], p being a function of whether the sum calculated in step a) must be strictly below the first threshold and if the sum calculated in step b) must be strictly less than the second threshold for the two conditions to be satisfied.
  • the predetermined set of fractiles consists of a single fractile.
  • the predetermined set of fractiles includes the median of the set of n input data.
  • the n weights are all equal to 1.
  • the set of n input data is a neighborhood of pixels in an image.
  • step a) comprises: a1) initializing a first counter to a sum having been calculated during a previous implementation of step a) by the processing module to process a previous data set comprising the same reference datum, the set of n input data further comprising at least one new datum which was not present in the previous dataset, and the previous dataset comprises at least one old datum which is not not present in the set of n input data, a2) for each new datum, increment the first counter with the weight associated with the new datum, only if a predetermined relationship between the value of the new datum and the value of the datum reference value is verified, a3) for each old datum, decrement the first counter with the weight associated with the old datum, only if a predetermined relationship between the value of the old datum and the value of the reference datum is verified.
  • step c) comprises: c1) initializing a second counter to a sum having been calculated during a previous implementation of step c) by the processing module to process a previous data set comprising the same reference datum, the set of n input data further comprising at least one new datum which was not present in the previous dataset, and the previous dataset comprises at least one old datum which is not not present in the set of n input data, c2) for each new datum, increment the second counter with the weight associated with the new datum, only if a predetermined relationship between the value of the new datum and the value of the datum reference value is verified, c3) for each old datum, decrement the second counter with the weight associated with the old datum, only a predetermined relationship between the value of the old datum and the value of the reference datum is verified.
  • the predetermined relationships are strict order relationships.
  • the set of n input data and the previous data set are neighborhoods of pixels in an image that overlap.
  • the processing module is also configured for:
  • step a) the sum calculated in step a) is less, strictly or not, than the third threshold and the sum calculated in step c) is less, strictly or not, than the fourth threshold.
  • a device for filtering a set of n input data so as to produce a fractile of the set included in a predetermined subset of fractiles, each input data having a value , each input data being also associated with a weight, the filtering device comprising:
  • each processing module being associated in its own right with one of the n input data and configured to process as reference data the input data of the set which is assigned to it. own partner,
  • a fractile generation module configured to generate the fractile on the basis of the output data respectively generated by the processing modules.
  • the filtering device can comprise the following characteristics, taken alone or combined with one another when this is technically possible.
  • the fractile generation module is configured for: f) for each output data item generated by a processing module, applying a bit-by-bit logic and type operation between the output data item generated by this processing module and the value of the input data associated specifically with the processing module, to output to produce results, g) applying a bit-by-bit logic or type operation to the results of step f).
  • the filtering device comprises a comparator configured to generate a result of comparison between the value of a first piece of data in the set and the value of a second piece of data in the set, and in which the plurality of processing modules comprises:
  • a first processing module configured to process as reference data a first data item of the set, the first processing module being configured to put in performs one of steps a) and c) on the basis of the result generated by the comparator,
  • a second processing module configured to process as reference data the second data of the set, the second processing module being configured to implement the other among steps a) and c) on the basis of the result generated by the same comparator.
  • the set of n input data comprises two input data common with a previous set of data previously processed by the filtering device, and one of the processing modules is configured to implement step a) or step c) on the basis of a result of comparison between the two common input data having been previously generated by the processing module to process the previous set of data.
  • step a) implemented by a processing module comprises: a1) initializing a first counter to a sum having been calculated during a previous implementation of step a) to filter a previous set of data, the set of n input data comprising at least one new data item which was not present in the previous data set, and comprising an input data item common with the previous data set, the previous data set comprising at least one old datum which is not present in the set of n input data, a2) for each new datum, increment the first counter with the weight associated with the new datum, only if a predetermined relation between the value of the new datum and the value of the common input datum is verified, a3) for each old datum, decrement the first counter with the weight associated with the old datum, only if a predetermined relationship between the value of the old datum and the value of the common input data is verified.
  • step c) implemented by a processing module comprises: c1) initializing a first counter to a sum having been calculated during a previous implementation of step c) to filter a previous set of data, the set of n input data comprising at least one new data item which was not present in the previous data set, and comprising an input data item common with the previous data set, the previous data set comprising at least one old datum which is not present in the set of n input data, c2) for each new datum, increment the first counter with the weight associated with the new datum, only if a predetermined relation between the value of the new data and the value of the common input data is verified, c3) for each old data, decrement the first counter with the associated weight to the old data, only if a predetermined relationship between the value of the old data and the value of the common input data is verified.
  • the predetermined relationships are strict relationships.
  • the number of processing modules arranged in parallel is strictly less than n, such that at least one of the n input data, called remaining data, is not processed as reference data by any of the processing modules, the filtering device further comprising an additional module configured to generate an output data indicating whether the remaining data is a fractile of the set included in the predetermined subset of fractiles, based on the output data generated by processing modules.
  • a device for processing an input image to produce an output image comprising:
  • a pixel selection module configured to select a neighborhood of n pixels in the input image
  • a filter device configured to filter the neighborhood of n pixels selected, so as to produce a fractile of the neighborhood of n pixels, the fractile constituting a value of one pixel of the output image.
  • a method of processing a set of n input data comprising a reference datum, each input datum having a value, each input datum being moreover associated with a. weight
  • the method comprising the following steps implemented by a processing module: a) calculating the sum of the weights associated only with the input data other than the reference datum which have values strictly lower than the value of the datum of reference, b) compare the sum calculated in step a) with a first threshold, c) calculate the sum of the weights associated only with the input data other than the reference data which have values strictly greater than the value of the reference data, d) compare the sum calculated in step c) with a second threshold, e) generate an output data indicating whether the reference data is a fractile of the set included in a predetermined subset of fractiles, only ent if the following two conditions are satisfied: the sum calculated in step a) is lower, strictly or not, at the first threshold and the sum calculated in step c) is
  • the set of n input data filtered by the method according to the fifth aspect is a neighborhood of pixels of an image.
  • a computer program product comprising program code instructions for the execution of the steps of the method according to the fifth aspect, when this program is executed by a computer.
  • FIG. 1 schematically illustrates a processing module according to a first embodiment of the invention.
  • FIG. 2 Figure 2 schematically illustrates a processing module according to a second embodiment of the invention.
  • FIG. 3 schematically illustrates a processing module according to a third embodiment of the invention.
  • FIG. 4 schematically illustrates a filtering device according to a first embodiment.
  • FIG. 5 schematically illustrates a filtering device according to a second embodiment.
  • FIG. 6 schematically illustrates an image processing device according to one embodiment.
  • FIG. 7 schematically illustrates a filtering device according to a third embodiment.
  • FIG. 8 schematically illustrates a filtering device according to a fourth embodiment.
  • FIG. 9 schematically illustrates part of an image and two neighborhoods of pixels selected in this image.
  • Figure 10 schematically illustrates part of an image and three neighborhoods of pixels selected in that image.
  • the processing module 1 takes as input a set of n input data. Each input data has a value.
  • processing module 1 is to test whether the value of one of the input data, qualified in the reference data series, is a predetermined fractile of the set of n input data.
  • the processing module 1 is configured to implement the following steps: a) calculate the number of input data other than the reference datum which have values strictly lower than the value of the reference datum, b) compare the number calculated in step a) with a first threshold Sa, c) calculate the number of input data other than the reference data which have values strictly greater than the value of the reference data, d) compare the sum calculated in step c) with a second threshold Sb, e) generating an output datum V0 indicating whether the reference datum is the predetermined fractile of the set of n data, only if the following two conditions are satisfied: the sum calculated at step a) is strictly less than the first threshold Sa and the sum calculated in step c) is strictly less than the second threshold Sb.
  • the processing module 1 comprises a plurality of primary comparators arranged in parallel. Each primary comparator has two inputs and one output. Each primary comparator is configured to compare two values that it receives via its two inputs, and provide on its output a result providing information on the comparison made.
  • Each primary comparator is limited to verifying whether the two values which are passed to it as input verify or not a predetermined binary relation R specific to the comparator. The result provided at the output is then Boolean information. In other words, each primary comparator is limited to checking whether xRy is true or not, where x and y are the two values received via the two inputs.
  • the inputs of the primary comparators are shown in the figures one above the other; by convention, x (operand to the left of R) is the value received on the top entry, and y (operand to the right of R) is the value received on the bottom entry.
  • x opernd to the left of R
  • y opernd to the right of R
  • the binary relation tested by a comparator is indicated in the figures by the corresponding symbol.
  • a result provided by a primary comparator is said to be positive if the binary relation R that it examines is verified by values that it receives as input, and is said to be negative otherwise.
  • a positive result is represented by the value 1
  • a negative result is represented by the value 0 (zero).
  • the binary relationship R verified by each primary comparator is a strict order relationship (R can thus be ⁇ or>).
  • the plurality of comparators thus comprises:
  • the first group of comparators of type> comprises two comparators of which o a comparator verifying whether PO> P1 or not and o a comparator verifying whether PO> P2 or not,
  • the second group of comparators of type ⁇ comprises two comparators of which o a comparator verifying whether PO ⁇ P1 or not and o a comparator verifying whether PO ⁇ P2 or not.
  • the processing module 1 furthermore comprises a first adder, and a second adder (designated in FIG. 1 by the sign +).
  • the first adder is connected to the respective outputs of the comparators of the first group.
  • the first adder is configured to determine the number of input data other than the input reference data which is strictly less than the PO value of the reference data (step a). This determined number is the output of the first adder.
  • the first adder can simply initialize a first counter to zero, and increment this counter by an increment equal to 1 each time the first adder receives a positive result from a comparator belonging to the first group.
  • the second adder is connected to the respective outputs of the comparators of the second group.
  • the second adder is configured to determine the number of input data other than the input reference data which is of a value strictly greater than the PO value of the reference data (step c). This determined number is the output of the second adder.
  • the second adder can simply initialize a second counter to zero, and increment this second counter by an increment equal to 1 each time the second adder receives a positive result from a comparator belonging to the second group.
  • the processing module 1 furthermore comprises a first secondary comparator and a second secondary comparator (located to the right of the adders).
  • the two secondary comparators are only comparators to verify a strict order relationship, just like the primary comparators. More precisely, the first secondary comparator (at the top right of FIG. 1) is configured to check whether the number determined by the first adder is strictly less than the first threshold Sa (step b) of the method). If so, the first comparator generates a positive result on its output, for example represented by the value 1; otherwise, the first comparator generates a negative result on its output, for example represented by the value 0.
  • the second secondary comparator (bottom right of FIG. 1) is configured to check whether the number determined by the second adder is strictly less than the second predetermined threshold Sb (step d) of the method). If so, the first comparator generates a positive result on its output, for example represented by the value 1; otherwise, the first comparator generates a negative result on its output, for example represented by the value 0.
  • the processing module 1 can include a gate of logic AND type taking as input the results supplied by the secondary comparators. In this case, when V0 is 1, V0 indicates that the value of the reference data is a predetermined fractile of the set of n input data.
  • the fractile tested by the processing module 1 depends on the values assigned to the two thresholds Sa, Sb.
  • the processing module 1 If the first threshold and the second threshold are each equal (n + 1) / 2, n being odd, then the fractile tested by the processing module 1 is a median; in other words, the processing module 1 then has the function of testing whether or not the value PO is the median of the values of the n input data.
  • the tested fractile is the maximum value among the values of the n input data.
  • the function of the module is to determine whether the reference value is the input data of the maximum value set.
  • the tested fractile is the minimum value among the values of the n input data.
  • the function of the module is to determine whether the reference value is the input data of the maximum value set.
  • the processing module 1 then proceeds as follows: • The two comparators of the first group each provide a positive result to the first adder, so that the first counter reaches the value 2 after being incremented twice. The value of the first counter is transmitted to the first secondary comparator, which notes that this value is not strictly less than the first threshold (the value of the first counter is in fact equal to the first threshold being (n + 1) / 2). The first secondary comparator therefore generates a negative result.
  • the two comparators of the second group each provide a negative result to the second adder, so that the second counter remains at zero.
  • the value of the second counter is transmitted to the first secondary comparator, which notes that this value is indeed strictly less than the second threshold (zero is indeed strictly less than (n + 1) / 2).
  • the second secondary comparator therefore generates a positive result.
  • processing module 1 comes to the conclusion that the PO value is not a median.
  • Processing module 1 proceeds as follows:
  • processing module 1 operates correctly even in the case where several of the n input data have equal values, in particular several values equal to the tested fractile. Illustrated in FIG. 2 is a processing module 2 according to a second embodiment. This second embodiment differs from the first embodiment by the following characteristics.
  • the primary comparators of the first group do not verify a strict order relation, but limit themselves to verifying an equality relation, which has the advantage of allowing a reduction of their area.
  • the result provided by a primary comparator of the first group is positive if the two compared values are equal, and this result is negative otherwise (if the two compared values are different).
  • the second group of primary comparators of type ⁇ comprises two comparators of which o a comparator verifying whether PO ⁇ P1 or not and o a comparator verifying whether PO ⁇ P2 or not.
  • the processing module 2 there are two comparators which compare the value of the reference datum and the value of the same other input datum, but the comparisons implemented by these two comparators are based on binary relations different, so that these two comparators provide results giving information of a different nature: one of these results indicates whether the value of the reference datum is equal or not to the other value, and the other indicates whether a strict order relation is verified by the reference data value and the value of the other input data.
  • the processing module 2 is configured to cross these two results of different kinds, to determine whether the other data should be counted by the first adder.
  • this crossing is implemented by means of an additional gate of logical NOR type taking as input the two results and whose output is connected to the first adder.
  • FIG. 3 Illustrated in FIG. 3 is a processing module 3 according to a third embodiment.
  • This third embodiment differs from the first embodiment by the following characteristics.
  • the primary comparators of the second group do not verify a strict order relation, but limit themselves to verifying an equality relation, which has the advantage of allowing a reduction of their area.
  • the result provided by a primary comparator of the second group is positive if the two compared values are equal, and this result is negative otherwise (if the two compared values are different).
  • the first group of primary comparators of type> comprises two comparators of which o a comparator verifying whether PO> P1 or not and o a comparator verifying whether PO> P2 or not,
  • the third embodiment there are in the third embodiment two comparators which compare the value of the reference datum and the value of another input datum, but the comparisons implemented by these two comparators are based on different binary relations, so that these two comparators provide results giving information of a different nature: one of these results indicates whether or not the value of the reference datum is equal to the other value, and l 'other indicates whether a strict order relation is satisfied by the reference data value and the value of the other input data.
  • the processing module according to the second embodiment is configured to cross these two results of different types, to determine whether the other data must be counted by the second adder.
  • this crossing is implemented by means of an additional gate of logical NOR type taking as input the two results and whose output is connected to the second adder.
  • This third embodiment has the same advantages of surface reduction as the second embodiment.
  • a filtering device 4 comprises a plurality of processing modules 1. Each of these modules 1 conforms to the first embodiment. It is however understood that each of these modules 1 could be replaced by a processing module 2 according to the second embodiment or a processing module 3 according to the third embodiment.
  • the filtering device 4 includes n inputs, one for each input data.
  • Each of the processing modules 1 of the filtering device 4 is associated in its own right with one of the input data.
  • Each processing module 1 is configured to process as reference data the input data associated with it.
  • the number of processing modules 1 of the filtering device 4 is thus at most equal to n.
  • the processing module processing the data of value Pi as reference data, an output data item Vi which indicates whether or not Pi is the predetermined fractile.
  • the processing modules 1 of the filtering device 4 are arranged in parallel, in the sense that they are configured to operate in parallel.
  • the filtering device 4 represented in FIG. 4, and for which we have n 3, thus comprises three processing modules 1, including:
  • a first processing module 1 processing the first datum of value PO as reference datum, output to produce the output datum VO which indicates whether PO is the sought fractile
  • a third processing module 1 processing the third data of value P2 as reference data, so as to produce an output data V2 indicating whether P1 is the sought fractile.
  • the filtering device 4 furthermore comprises a fractile generation module 6.
  • the generation module 6 is connected to the respective outputs of the different processing modules 1 arranged in parallel, so that this generation module 6 receives n data Vi.
  • Generation 6 module is configured to select the value of one of the n input data as output data based on this data Vi.
  • the generation module 6 has a structure using only bitwise AND and OR operators. More precisely, the selection module comprises a plurality of bit-by-bit logic AND type gates, each of these gates taking as input one of the data Vi, and moreover the associated data Pi. The selection module also comprises a bit-by-bit logic OR gate, taking as input the respective outputs of the bit-by-bit logic AND type gates. This gate provides as an output the fractile sought by the filtering device 4 (therefore, for example, the median value of the values of the n input data). This structure is advantageous because it does not contain priority logic. It therefore uses fewer logic levels than a structure containing such priority logic, thus allowing a higher potential for frequency increase.
  • the Generation 6 module may include a Fractile Indicator Priority encoder, followed by a multiplexer.
  • FIG. 5 shows a filtering device 5 according to a second embodiment.
  • This filtering device 5 differs from the filtering device 4 in that its number of processing modules 1 is strictly less than n, such that at least one of the n input data, called the remaining data, is not processed as reference data by any of the processing modules 1.
  • the filtering device 5 comprises an additional module 7 configured to generate an output datum indicating whether the remaining datum is the desired fractile, on the basis of the output data generated by the processing modules 1.
  • the number of processing modules is for example equal to n-1, so that there is only one input data item remaining.
  • the input data for which there is no 'has not been associated with a processing module (here, P2) is necessarily the desired fractile.
  • the complementary module can be an additional gate of logical NOR type taking as input the outputs of the processing modules Vi and whose output to the fractile generation module 6.
  • This embodiment is advantageous because the surface required for the additional module is less than that of a processing module 1. The general implementation surface of the device is thus reduced.
  • an image processing device 10 comprises a pixel selection module 12, at least one filtering device 4 arranged at the output of the pixel selection module 12, and an image generation module 14 arranged at the outlet of the filtering device 4.
  • the device 4 can be replaced by the device 5 in the image processing device 10.
  • the function of the image processing device 10 is to produce a filtered output image from an input image, this filtering being applied by the filtering device 4.
  • the pixel selection module 12 is configured to receive an input image A.
  • the input image A comprises a plurality of pixels, each pixel having its own position in the input image (this position is typically in the form of a pair of row and column indices).
  • Each pixel of input image A also has at least one value that indicates its color. In the following, we will first assume that each pixel of the input image A has a single value, which indicates a gray level.
  • the pixel selection module 12 is configured to select in the input image A a neighborhood of n pixels associated with a pixel of the image A called the main pixel.
  • this neighborhood typically comprises the main pixel, and two neighboring pixels of the main pixel.
  • the two neighboring pixels are typically located on either side of the main pixel (on the same column or on the same row in the input image A).
  • the neighborhood forms a square of pixels centered on the main pixel, and comprising the eight pixels neighboring the main pixel.
  • the filtering device 4 is arranged to receive as input the respective values of the neighborhood of n pixels selected by the pixel selection module 12.
  • the input data processed by the filtering device 4 are here the values. n pixels which constitute the neighborhood of pixels selected by the pixel selection module 12.
  • the filtering device 4 outputs a filtered pixel value V, associated with the main pixel.
  • the image processing device 10 is configured to repeat the preceding steps over several successive iterations, each iteration taking as input a new pixel of the input image considered as the main pixel by the pixel selection module 12.
  • the filtering device produces as many filtered pixel values V as input pixels successively processed as main pixels by the pixel selection module.
  • the generation module 14 is configured to generate an output image B from all of these filtered pixel values V supplied by the filter device 4.
  • this embodiment makes it possible to eliminate outliers of the pixel values in the input image A.
  • each pixel of the input image may include not a single value but a k-tuple of color components, the k-tuple being characteristic of the color of the pixel.
  • This k-tuple is for example a triplet of red, green and blue components.
  • the input image is a superposition of k elementary images, each elementary image relating to one of the k components of the input image A.
  • the pixel selection module 12 is configured to supply the filtering device with the n pixel values of a neighborhood belonging to the same color component.
  • the filtering device can thus be called upon k times, once per component, thus allowing the generation module to generate an output color image.
  • the image processing device 10 can comprise k filtering devices 4 arranged in parallel, each filtering device 4 being associated with one of the k components of the input image.
  • the filtering device 11 comprises all the components of the filtering device 4, in particular the three processing modules 1 discussed previously, aimed at testing whether different input data is a predetermined fractile of the set, which is called in what follows first fractile, using the thresholds Sa and Sb for this.
  • the filtering device 11 furthermore comprises three additional processing modules having the same structure as the modules of the device 4, but testing a second fractile different from the first fractile, using thresholds Sa 'and Sb' having potentially different values. thresholds Sa and Sb.
  • a fourth processing module 1 processing the first PO value datum as reference datum, output to produce the output datum V'0 which indicates whether PO is the second sought fractile
  • a sixth processing module 1 processing the third datum of value P2 as reference datum, so as to produce an output datum V’2 indicating whether P1 is the second sought fractile.
  • the filtering device 11 comprises the same n inputs as the filtering device 4. On the other hand, it comprises two outputs and not just one: the first output, already present in the filtering device 4, delivers the first fractile, and the second output delivers the second fractile. This second output is delivered by an additional fractile generation module having for example a structure identical to the module 6 shown in FIG. 4.
  • a processing module 1 is extended to implement the following additional steps:
  • the pair of thresholds (Sa ’, Sb’) is different from the pair of thresholds (Sa, Sb).
  • the total number of primary comparators necessary to obtain the n data Vi which are then passed to the input of the output selection module is relatively large.
  • This optimization is called by symmetry because it is based on the symmetrical character of the comparisons carried out: x strictly greater than y is equivalent to y strictly smaller than x.
  • This filtering device 8 comprises components of the same type as those of the filtering device 4, but differs from the latter by a smaller number of primary comparators.
  • a primary comparator configured to compare the respective values PO, P1 of the first input datum and of the second input datum is part of the first group of comparators of the first processing module, and at the same time is part of the second group of comparators of the second processing module.
  • this comparator is configured to compare PO and P1 and to provide a result which is then used by two adders:
  • this other comparator is configured to compare PO and P1 and to provide a result which is then used by two adders:
  • the first processing module and the second processing module have the two preceding comparators in common, and these two comparators in common have the particularity that they compare the respective values of the two data associated with these two processing modules. .
  • This principle can be generalized to each pair of processing modules present in the filtering device. It is thus possible to halve the total number of primary comparators, which further reduces the area of implementation of the filtering device.
  • the symmetrically optimized filtering device 8 can replace the filtering device 4 in the image processing device 10.
  • steps a) and c) implemented by any one of the processing modules 1, 2, 3 can also be optimized when the processing module concerned is made to operate repeatedly by successive iterations, over sets of mutually overlapping input data.
  • the processing module according to one of these embodiments is part of a filtering device which is itself part of a device.
  • image processing 10 such as that shown in Figure 6.
  • the pixel selection module 12 can be configured to perform a scan of the input image A, such that the neighborhood of n selected pixels during a current iteration and the neighborhood of n pixels selected during a previous iteration overlap.
  • the two neighborhoods are for example shifted by one pixel horizontally or vertically (which means that the two pixels successively processed as reference pixel by the pixel selection module 12 during these two successive iterations are mutually neighboring).
  • current set is used to refer to a set of n input data processed by a processing module of the filtering device during a current iteration, and “previous set” to a set of n input data processed by the same processing module during a previous iteration.
  • the current set differs from the previous set in that it includes at least one new input datum which was not present in the previous set, and in that it does not include at least one old datum which was nevertheless present. in the previous game. However, the current game has at least one input in common with the previous game.
  • the current iteration and the previous iteration process the same input data as reference data.
  • the example of the processing module according to the first embodiment shown in FIG. 1 will be taken, but the following is also applicable to the embodiments of FIGS. 2 and 3.
  • steps a) and c) include the initialization of a first counter and a second counter to zero.
  • Step a) of the current iteration then comprises the following steps: a1) initialize the first counter to said saved sum, a2) for each new data item in the current set, increment the first counter by one only if the value of the new one data is strictly less than the value of the reference datum, a3) for each old datum, decrement the first counter by one only if the value of the old datum is strictly less than the value of the reference datum.
  • Step c) of the current iteration then comprises the following steps: c1) initialize the second to said saved sum, c2) for each new data item in the current set, increment the second counter by one only if the value of the new data item is strictly greater than the value of the reference datum, c3) for each old datum, decrement the second counter by one only if the value of the old datum is strictly greater than the value of the reference datum.
  • steps a2), a3), c2) and c3) use strict order relationships. However, this is not necessary to implement a sliding sum optimization.
  • the input data processed by the same processing module 1, 2, 3 as reference data during the current iteration and during the previous iteration are different.
  • sliding sum optimization involves communication between different processing modules of the filtering device.
  • steps a1 -a3) or c1 -3) implemented by a processing module are then based on a sum saved by another processing module.
  • ternary adders having three inputs instead of two as illustrated in Figures 1 to 3 (the third input being used to receive the value saved during the previous iteration).
  • Such adders can be implemented using a per bit LUT6.
  • This optimization is based on the idea that two input data in common between a current set and a previous set do not need to be compared twice, once during the previous iteration and once. more times during the current iteration. Instead, the result of a comparison between two values made during the previous iteration and saved, then reused by an adder during the current iteration, if these two values are found to relate to input data which is still present in the set processed during the current iteration.
  • the result of a comparison made between the values P1 and P2 can be saved during the previous iteration; this saved result can then be used by an adder during the current iteration.
  • there is new data four partially common data, four completely common data, and six old data.
  • partially common data is meant data of the current set which belongs to only one of the previous sets, and by completely common data data of the current set which belongs to the two previous sets.
  • the filter device 4, 8 has already produced the results of the comparisons between the fully common data values, the results of the comparisons between the partially common data values and the fully common data values, and the results of the comparisons between the partially common given values that belong to the same previous set. According to propagation optimization these results were saved.
  • the filtering device must therefore perform 12 comparisons during the current step with the optimization by propagation against 72 (9 times 8) comparisons without the optimization by propagation.
  • This optimization by propagation therefore has the advantage of greatly reducing the number of comparisons to be made during a current iteration, the filtering device 4, 8 being limited to performing the comparisons the results of which have not been produced previously. .
  • the conditions verified in step e) are based on a strict order relation ( ⁇ ): thus, it is verified whether the number obtained in step a) is strictly less than the first threshold Sa, and similarly if the number obtained in step c) is strictly less than the threshold Sb. Moreover, the sum of the thresholds Sa and Sb is equal to n + 1.
  • At least one of the two conditions verified in step e) is based on a non-strict relation ( ⁇ ).
  • the sum of the thresholds Sa and Sb could be equal to n-1 (in the case where the two conditions use the relation of order ⁇ ) or equal to n (in the case where one two conditions use the relation of order ⁇ , and the other uses the strict order relation ⁇ ).
  • the sum of the two thresholds is equal to n + p, with p C [-1, 1], p being a function of whether the sum calculated in step a) must be less than the first threshold Sa in a strict manner and if the sum calculated in step b) must be less than the second threshold Sb in a strict manner, so that the two conditions are satisfied.
  • p is a function of the strictness or not of the order relations used during step e).
  • the fractile tested is not necessarily the median.
  • the fractile f tested by a processing module can be any (f being a percentage, between 0% and 100%).
  • upper rounding is meant lower rounding + 1.
  • the function of the processing module 1, 2, 3 discussed above is to test whether a reference input data item is a specific fractile, for example the median of the set of n input data.
  • This test can be generalized: it can thus be tested by a processing module if the reference datum is a fractile of the set of n data which is included in a predetermined subset of fractiles.
  • the term “subset” of a fractile is intended to mean that there exists at least one fractile that does not belong to this subset. In other words, the desired subset of fractiles is not the set of all possible fractiles, ranging from 0% to 100%, but is included in it.
  • At least one of the minimum and the maximum of the set of n data is excluded from the predetermined subset of fractiles.
  • the test applied by a processing module to a reference datum having a maximum or minimum value in the set of n data will be negative.
  • thresholds Sa, Sb used in modules 1, 2 or 3 can set to values such that their sum is not necessarily equal to n + p. These thresholds define a continuous subset of several fractiles. It is also conceivable to replicate the device as shown in FIG. 7 to obtain a subset of several discontinuous fractiles.
  • the subset of several fractiles is continuous, includes the median of the set of n data, and includes at least one other fractile.
  • the generation module 6 functions as a selector. However, other embodiments can be provided in which the value produced at the output of this module does not correspond to any of the respective values of the n input data. This case can especially occur when n is even. In this case, there can be two medians (a low median and a high median). Generation module 6 can then calculate the arithmetic mean of these two medians.
  • an input data count is performed in steps a) and c) (the increment used to increment the first counter and the second counter is one).
  • each input datum is associated with a predetermined weight, coming in addition to the value of the input datum.
  • the modifications are then made to a processing module.
  • step a) the sum of the weights associated only with the input data other than the reference datum which have values strictly lower than the value of the reference datum is calculated.
  • step c) the sum of the weights associated only with the input data other than the reference datum which have values strictly greater than the value of the reference datum is calculated.
  • the first counter and the second counter are incremented with weights, and no longer necessarily with one.
  • the sum of the first threshold Sa and of the second threshold Sb is chosen equal to s + p, s being the sum of the weights of the n input data.
  • the weight associated with a pixel in the neighborhood can be a function of the position relative between this pixel and the reference pixel.
  • the number n is however preferably odd, which advantageously lends itself to the setting. implementing a pixel filter centered on a reference pixel, this filter taking account of the reference pixel.
  • n is an odd square (which allows the implementation of a filter on a neighborhood of pixels of square shape around a reference pixel, this filter taking into account of the reference pixel).
  • each of the processing modules 1, 2, 3 respectively represented in FIGS. 1, 2 and 3 are suitable for implementing the method of processing a set of n input data exposed at the start of the this detailed description, comprising steps a) to d).
  • These different processing modules 1, 2, 3 are typically in the form of electronic circuits (FPGA, ASIC or other); the various blocks represented in these figures are thus physical components included in these electronic circuits.
  • these processing modules occupy a very limited area because they do not perform a complex operation such as sorting.
  • processing modules 1, 2, 3 are used in parallel, which makes it possible to reduce the average duration of determining a desired fractile.
  • it can be envisaged to repeat sequentially the processing method implemented by a processing module 1, 2 or 3, rather than parallelizing it, until a fractile which corresponds to what is sought is found. This repetition is in particular easy to implement when the method is implemented in software; in this case it is possible to use only one processor for this sequential implementation.
  • This variant is on average slower than the parallelized variant, but has the advantage of consuming less computation load at a time t.
  • a sequential implementation is also particularly advantageous when one is looking not for a single fractile, but more generally for a fractile belonging to a subset of continuous fractiles. Indeed, the execution of the method will remain fast, because a test of membership in a subset is easier to verify than a search for a single fractile. We can for example be satisfied with a fractile close to the median, in the extent to which the time taken to obtain it is faster than the time that it would take to determine the precise median.

Landscapes

  • Engineering & Computer Science (AREA)
  • Physics & Mathematics (AREA)
  • General Physics & Mathematics (AREA)
  • Theoretical Computer Science (AREA)
  • Computational Mathematics (AREA)
  • Mathematical Analysis (AREA)
  • Pure & Applied Mathematics (AREA)
  • Data Mining & Analysis (AREA)
  • Mathematical Optimization (AREA)
  • Mathematical Physics (AREA)
  • Multimedia (AREA)
  • General Engineering & Computer Science (AREA)
  • Bioinformatics & Cheminformatics (AREA)
  • Bioinformatics & Computational Biology (AREA)
  • Life Sciences & Earth Sciences (AREA)
  • Evolutionary Biology (AREA)
  • Operations Research (AREA)
  • Probability & Statistics with Applications (AREA)
  • Algebra (AREA)
  • Databases & Information Systems (AREA)
  • Software Systems (AREA)
  • Computing Systems (AREA)
  • Image Processing (AREA)

Abstract

Module de traitement d'un jeu de n données d'entrée comprenant une donnée de référence, configuré pour a) calculer la somme de poids associés seulement aux données d'entrée autres que la donnée de référence ayant des valeurs strictement inférieures à la valeur de la donnée de référence, b) comparer la somme calculée à l'étape a) avec un premier seuil, c) calculer la somme des poids associés seulement aux données d'entrée autres que la donnée de référence ayant des valeurs strictement supérieures à la valeur de la donnée de référence, d) comparer la somme calculée à l'étape c) avec un deuxième seuil, e) générer une donnée de sortie indiquant si la donnée de référence est un fractile du jeu inclus dans un sous-ensemble prédéterminé de fractiles, seulement si : la somme calculée à l'étape a) est inférieure au premier seuil et la somme calculée à l'étape c) est inférieure au deuxième seuil.

Description

DESCRIPTION
TITRE : Module de traitement de données identifiant un fractile d’un jeu de données DOMAINE DE L'INVENTION
La présente invention se rapporte au domaine des procédés et dispositifs permettant de d’identifier, dans un jeu de données, un fractile appartenant à un sous-ensemble prédéterminé de fractiles, tel qu’une médiane.
ETAT DE LA TECHNIQUE
On connaît du document US 2012/076432 un dispositif de filtrage d’un jeu de n données d’entrée de sorte à produire une valeur de sortie. La valeur de sortie est la médiane des valeurs respectives des n données d’entrée. La médiane est un fractile spécifique qui divise le jeu de n données (une fois celui-ci ordonné) en deux groupes de tailles égales.
Ce dispositif comprend plusieurs unités de traitements, dont une unité de détermination effectuant une recherche de minimum pour déterminer la médiane.
L’inconvénient de ce dispositif est que la recherche de minimum mise en oeuvre est une opération relativement complexe. Ceci a deux conséquences : cette recherche rallonge le temps de traitement du dispositif, et ne peut pas être implémentée dans des composants de surface extrêmement réduite.
EXPOSE DE L'INVENTION
Un but de l’invention est de déterminer un fractile d’un jeu de données de manière plus rapide et/ou implémentable sur une surface extrêmement réduite.
Il est à cet effet proposé, selon un premier aspect, un module de traitement d’un jeu de n données d’entrée comprenant une donnée de référence, chaque donnée d’entrée ayant une valeur, chaque donnée d’entrée étant par ailleurs associée à un poids, le module de traitement étant configuré pour : a) calculer la somme des poids associés seulement aux données d’entrée autres que la donnée de référence qui ont des valeurs strictement inférieures à la valeur de la donnée de référence, b) comparer la somme calculée à l’étape a) avec un premier seuil, c) calculer la somme des poids associés seulement aux données d’entrée autres que la donnée de référence qui ont des valeurs strictement supérieures à la valeur de la donnée de référence, d) comparer la somme calculée à l’étape c) avec un deuxième seuil, e) générer une donnée de sortie indiquant si la donnée de référence est un fractile du jeu inclus dans un sous-ensemble prédéterminé de fractiles, seulement si les deux conditions suivantes sont satisfaites : la somme calculée à l’étape a) est inférieure, strictement ou non, au premier seuil et la somme calculée à l’étape c) est inférieure, strictement ou non, au deuxième seuil.
Le module selon le premier aspect peut comprend les caractéristiques suivantes, prises seules ou combinées entre elles lorsque cela est techniquement possible.
De préférence, la donnée de sortie est un booléen.
De préférence, le module de traitement comprend :
- une pluralité de premiers comparateurs agencés en parallèle, chaque premier comparateur étant configuré pour générer un résultat de comparaison entre la valeur de la donnée de référence et la valeur d’une autre donnée d’entrée du jeu,
- un premier additionneur configuré pour mettre en oeuvre l’étape a) sur la base des résultats générés par les premiers comparateurs.
De préférence, le module de traitement comprend :
- une pluralité de deuxièmes comparateurs agencés en parallèle, chaque deuxième comparateur étant configuré pour générer un résultat de comparaison entre la valeur de la donnée de référence et la valeur d’une autre donnée d’entrée du jeu,
- un deuxième additionneur configuré pour mettre en oeuvre l’étape c) sur la base de résultats générés par les deuxièmes comparateurs.
De préférence, le module de traitement comprend : deux comparateurs configurés pour générer respectivement deux résultats de comparaison entre la valeur de la donnée de référence et la valeur d’une autre donnée d’entrée du jeu, dans lequel l’un des deux comparateurs est configuré pour se borner à tester une égalité entre la valeur de la donnée de référence et la valeur de l’autre donnée d’entrée du jeu, et l’autre des deux comparateurs est configuré pour se borner à tester une relation d’ordre entre la valeur de la donnée de référence et la valeur de l’autre donnée d’entrée du jeu, le module de traitement étant par ailleurs configuré pour croiser les deux résultats pour déterminer si le poids de l’autre valeur est à inclure dans la somme calculée à l’étape a) ou dans la somme calculée à l’étape c).
De préférence, la somme du premier seuil et du deuxième seuil est égale à s+p, où s est la somme des poids des n données d’entrée, et où p e [-1 , 1 ], p étant fonction de savoir si la somme calculée à l’étape a) doit être inférieure au premier seuil de manière stricte et si la somme calculée à l’étape b) doit être inférieure au deuxième seuil de manière stricte pour que les deux conditions soient satisfaites.
De préférence, l’ensemble de fractiles prédéterminé est constitué d’un unique fractile.
De préférence, l’ensemble de fractiles prédéterminé comprend la médiane du jeu de n données d’entrée.
De préférence, les n poids sont tous égaux à 1.
De préférence, le jeu de n données d’entrée est un voisinage de pixels dans une image.
De préférence, l’étape a) comprend : a1 ) initialiser un premier compteur à une somme ayant été calculée lors d’une précédente mise en oeuvre de l’étape a) par le module de traitement pour traiter un précédent jeu de données comprenant la même donnée de référence, le jeu de n données d’entrée comprenant par ailleurs au moins une nouvelle donnée qui n’était pas présente dans le précédent jeu de données, et le précédent jeu de données comprend au moins une ancienne donnée qui n’est pas présente dans le jeu de n données d’entrée, a2) pour chaque nouvelle donnée, incrémenter le premier compteur avec le poids associé à la nouvelle donnée, seulement si une relation prédéterminée entre la valeur de la nouvelle donnée et la valeur de la donnée de référence est vérifiée, a3) pour chaque ancienne donnée, décrémenter le premier compteur avec le poids associé à l’ancienne donnée, seulement si une relation prédéterminée entre la valeur de l’ancienne donnée et la valeur de la donnée de référence est vérifiée.
De préférence, l’étape c) comprend : c1 ) initialiser un deuxième compteur à une somme ayant été calculée lors d’une précédente mise en oeuvre de l’étape c) par le module de traitement pour traiter un précédent jeu de données comprenant la même donnée de référence, le jeu de n données d’entrée comprenant par ailleurs au moins une nouvelle donnée qui n’était pas présente dans le précédent jeu de données, et le précédent jeu de données comprend au moins une ancienne donnée qui n’est pas présente dans le jeu de n données d’entrée, c2) pour chaque nouvelle donnée, incrémenter le deuxième compteur avec le poids associé à la nouvelle donnée, seulement si une relation prédéterminée entre la valeur de la nouvelle donnée et la valeur de la donnée de référence est vérifiée, c3) pour chaque ancienne donnée, décrémenter le deuxième compteur avec le poids associé à l’ancienne donnée, seulement une relation prédéterminée entre la valeur de l’ancienne donnée et la valeur de la donnée de référence est vérifiée. De préférence, les relations prédéterminées sont des relations d’ordre strict.
De préférence, le jeu de n données d’entrée et le précédent jeu de données sont des voisinages de pixels dans une image qui se chevauchent.
De préférence, le module de traitement est par ailleurs configuré pour :
- b') comparer la somme calculée à l’étape a) avec un troisième seuil,
- d’) comparer la somme calculée à l’étape c) avec un quatrième seuil,
- e’) générer une donnée de sortie indiquant si la donnée de référence est un fractile du jeu inclus dans un deuxième sous-ensemble prédéterminé de fractiles différent du sous- ensemble de l’étape e), seulement si les deux conditions suivantes sont satisfaites : la somme calculée à l’étape a) est inférieure, strictement ou non, au troisième seuil et la somme calculée à l’étape c) est inférieure, strictement ou non, au quatrième seuil.
Il est également proposé, selon un deuxième aspect, un dispositif de filtrage d’un jeu de n données d’entrée de sorte à produire un fractile du jeu inclus dans un sous-ensemble prédéterminé de fractiles, chaque donnée d’entrée ayant une valeur, chaque donnée d’entrée étant par ailleurs associée à un poids, le dispositif de filtrage comprenant :
- une pluralité de modules de traitement selon le premier aspect, agencés en parallèle, chaque module de traitement étant associé en propre à une des n données d’entrée et configuré pour traiter comme donnée de référence la donnée d’entrée du jeu qui lui est associée en propre,
- un module de génération de fractile configuré pour générer le fractile sur la base des données de sortie respectivement générées par les modules de traitement.
Le dispositif de filtrage selon le deuxième aspect peut comprend les caractéristiques suivantes, prises seules ou combinées entre elles lorsque cela est techniquement possible.
De préférence, le module de génération de fractile est configuré pour : f) pour chaque donnée de sortie générée par un module de traitement, appliquer une opération de type et logique bit à bit entre la donnée de sortie générée par ce module de traitement et la valeur de la donnée d’entrée associée en propre au module de traitement, de sortir à produire des résultats, g) appliquer une opération de type ou logique bit à bit aux résultats de l’étape f).
De préférence, le dispositif de filtrage comprend un comparateur configuré pour générer un résultat de comparaison entre la valeur d’une première donnée du jeu et la valeur d’une deuxième donnée du jeu, et dans lequel la pluralité de modules de traitement comprend :
- un premier module de traitement configuré pour traiter comme donnée de référence une première donnée du jeu, le premier module de traitement étant configuré pour mettre en œuvre l’une parmi les étapes a) et c) sur la base du résultat généré par le comparateur,
- un deuxième module de traitement configuré pour traiter comme donnée de référence la deuxième donnée du jeu, le deuxième module de traitement étant configuré pour mettre en œuvre l’autre parmi les étapes a) et c) sur la base du résultat généré par le même comparateur.
De préférence, le jeu de n données d’entrées comprend deux données d’entrée communes avec un précédent jeu de données préalablement traité par le dispositif de filtrage, et un des modules de traitement est configuré pour mettre en œuvre l’étape a) ou l’étape c) sur la base d’un résultat de comparaison entre les deux données d’entrée communes ayant été préalablement généré par le module de traitement pour traiter le précédent jeu de donnée.
De préférence, l’étape a) mise en œuvre par un module de traitement comprend : a1 ) initialiser un premier compteur à une somme ayant été calculée lors d’une précédente mise en œuvre de l’étape a) pour filtrer un précédent jeu de données, le jeu de n données d’entrée comprenant au moins une nouvelle donnée qui n’était pas présente dans le précédent jeu de données, et comprenant une donnée d’entrée commune avec le précédent jeu de données, le précédent jeu de données comprenant au moins une ancienne donnée qui n’est pas présente dans le jeu de n données d’entrée, a2) pour chaque nouvelle donnée, incrémenter le premier compteur avec le poids associé à la nouvelle donnée, seulement si une relation prédéterminée entre la valeur de la nouvelle donnée et la valeur de la donnée d’entrée commune est vérifiée, a3) pour chaque ancienne donnée, décrémenter le premier compteur avec le poids associé à l’ancienne donnée, seulement si une relation prédéterminée entre la valeur de l’ancienne donnée et la valeur de la donnée d’entrée commune est vérifiée.
De préférence, l’étape c) mise en œuvre par un module de traitement comprend : c1 ) initialiser un premier compteur à une somme ayant été calculée lors d’une précédente mise en œuvre de l’étape c) pour filtrer un précédent jeu de données, le jeu de n données d’entrée comprenant au moins une nouvelle donnée qui n’était pas présente dans le précédent jeu de données, et comprenant une donnée d’entrée commune avec le précédent jeu de données, le précédent jeu de données comprenant au moins une ancienne donnée qui n’est pas présente dans le jeu de n données d’entrée, c2) pour chaque nouvelle donnée, incrémenter le premier compteur avec le poids associé à la nouvelle donnée, seulement si une relation prédéterminée entre la valeur de la nouvelle donnée et la valeur de la donnée d’entrée commune est vérifiée, c3) pour chaque ancienne donnée, décrémenter le premier compteur avec le poids associé à l’ancienne donnée, seulement si une relation prédéterminée entre la valeur de l’ancienne donnée et la valeur de la donnée d’entrée commune est vérifiée.
De préférence, les relations prédéterminées sont des relations d’ordre strict.
De préférence, le nombre de modules de traitement agencés en parallèle est strictement inférieur à n, de telle sorte qu’au moins une des n données d’entrée, dite donnée restante, n’est pas traitée comme donnée de référence par un quelconque des modules de traitement, le dispositif de filtrage comprenant par ailleurs un module complémentaire configuré pour générer une donnée de sortie indiquant si la donnée restante est un fractile du jeu inclus dans le sous-ensemble prédéterminé de fractiles, sur la base des données de sortie générées par les modules de traitements.
Il est également proposé, selon un troisième aspect, un dispositif de traitement d’une image d’entrée pour produire une image de sortie, le dispositif de traitement comprenant :
- un module de sélection de pixels configuré pour sélectionner un voisinage de n pixels dans l’image d’entrée,
- un dispositif de filtrage selon le deuxième aspect, configuré pour filtrer le voisinage de n pixels sélectionné, de sorte à produire un fractile du voisinage de n pixels, le fractile constituant une valeur d’un pixel de l’image de sortie.
Il est également proposé, selon un quatrième aspect, un procédé de traitement d’un jeu de n données d’entrée comprenant une donnée de référence, chaque donnée d’entrée ayant une valeur, chaque donnée d’entrée étant par ailleurs associée à un poids, le procédé comprenant les étapes suivantes mises en oeuvre par un module de traitement : a) calculer la somme des poids associés seulement aux données d’entrée autres que la donnée de référence qui ont des valeurs strictement inférieures à la valeur de la donnée de référence, b) comparer la somme calculée à l’étape a) avec un premier seuil, c) calculer la somme des poids associés seulement aux données d’entrée autres que la donnée de référence qui ont des valeurs strictement supérieures à la valeur de la donnée de référence, d) comparer la somme calculée à l’étape c) avec un deuxième seuil, e) générer une donnée de sortie indiquant si la donnée de référence est un fractile du jeu inclus dans un sous-ensemble prédéterminé de fractiles, seulement si les deux conditions suivantes sont satisfaites : la somme calculée à l’étape a) est inférieure, strictement ou non, au premier seuil et la somme calculée à l’étape c) est inférieure, strictement ou non, au deuxième seuil.
Il est également proposé, selon un cinquième aspect, un procédé de filtrage d’un jeu de n données d’entrée de sorte à produire un fractile du jeu inclue dans un sous-ensemble prédéterminé de fractiles, chaque donnée d’entrée ayant une valeur, chaque donnée d’entrée étant par ailleurs associée à un poids, le procédé comprenant :
- mettre en oeuvre le procédé de traitement selon le quatrième aspect plusieurs fois en parallèle, chaque mise en oeuvre dudit procédé de traitement traitant une donnée d’entrée différente du jeu comme donnée de référence,
- générer le fractile sur la base des données de sortie générées lors des mises en oeuvre parallèles du procédé de traitement.
De préférence, le jeu de n données d’entrée filtré par le procédé selon le cinquième aspect est un voisinage de pixels d’une image.
Il est également proposé, selon un sixième aspect, un produit programme d'ordinateur comprenant des instructions de code de programme pour l'exécution des étapes du procédé selon le cinquième aspect, lorsque ce programme est exécuté par un ordinateur.
DESCRIPTION DES FIGURES
D’autres caractéristiques, buts et avantages de l’invention ressortiront de la description qui suit, qui est purement illustrative et non limitative, et qui doit être lue en regard des dessins annexés sur lesquels :
[Fig. 1] La figure 1 illustre de façon schématique un module de traitement selon un premier mode de réalisation de l’invention.
[Fig. 2] La figure 2 illustre de façon schématique un module de traitement selon un deuxième mode de réalisation de l’invention.
[Fig. 3] La figure 3 illustre de façon schématique un module de traitement selon un troisième mode de réalisation de l’invention.
[Fig. 4] La figure 4 illustre de façon schématique un dispositif de filtrage selon un premier mode de réalisation.
[Fig. 5] La figure 5 illustre de façon schématique un dispositif de filtrage selon un deuxième mode de réalisation. [Fig. 6] La figure 6 illustre de façon schématique un dispositif de traitement d’image selon un mode de réalisation.
[Fig. 7] La figure 7 illustre de façon schématique un dispositif de filtrage selon un troisième mode de réalisation.
[Fig. 8] La figure 8 illustre de façon schématique un dispositif de filtrage selon un quatrième mode de réalisation.
[Fig. 9] La figure 9 illustre de façon schématique une partie d’une image et deux voisinages de pixels sélectionnés dans cette image.
[Fig. 10] La figure 10 illustre de façon schématique une partie d’une image et trois voisinages de pixels sélectionnés dans cette image.
Sur l’ensemble des figures, les éléments similaires portent des références identiques.
DESCRIPTION DETAILLEE DE L'INVENTION
On a représenté en figure 1 un module de traitement 1 selon un premier mode de réalisation. Le module de traitement 1 prend en entrée un jeu de n données d’entrée. Chaque donnée d’entrée a une valeur.
Le module de traitement 1 a pour fonction de tester si la valeur d’une des données d’entrée, qualifiée dans la suite de donnée de référence, est un fractile prédéterminé du jeu de n données d’entrée.
Le module de traitement 1 est configuré pour mettre en oeuvre les étapes suivantes : a) calculer le nombre de données d’entrée autres que la donnée de référence qui ont des valeurs strictement inférieures à la valeur de la donnée de référence, b) comparer le nombre calculée à l’étape a) avec un premier seuil Sa, c) calculer le nombre de données d’entrée autres que la donnée de référence qui ont des valeurs strictement supérieures à la valeur de la donnée de référence, d) comparer la somme calculée à l’étape c) avec un deuxième seuil Sb, e) générer une donnée V0 de sortie indiquant si la donnée de référence est le fractile prédéterminé du jeu de n données, seulement si les deux conditions suivantes sont satisfaites : la somme calculée à l’étape a) est strictement inférieure au premier seuil Sa et la somme calculée à l’étape c) est strictement inférieure au deuxième seuil Sb.
Dans le mode de réalisation illustré sur la figure 1 , on a n=3. Les valeurs respectives des trois données d’entrée sont notées PO, P1 , P2. La valeur de la donnée de référence est PO. On va maintenant détailler la structure du module de traitement 1 qui lui permet de mettre en œuvre les étapes qui précèdent.
Le module de traitement 1 comprend une pluralité de comparateurs primaires agencés en parallèle. Chaque comparateur primaire comprend deux entrées et une sortie. Chaque comparateur primaire est configuré pour comparer deux valeurs qu’il reçoit via ses deux entrées, et fournir sur sa sortie un résultat renseignant sur la comparaison effectuée.
Chaque comparateur primaire se borne à vérifier si les deux valeurs qui lui sont passées en entrée vérifient ou non une relation binaire R prédéterminée propre au comparateur. Le résultat fourni en sortie est alors une information booléenne. Autrement dit chaque comparateur primaire se borne à vérifier si xRy est vrai ou non, où x et y sont les deux valeurs reçues via les deux entrées.
Les entrées des comparateurs primaires sont représentées sur les figures l’une au-dessus de l’autre ; par convention, x (opérande à gauche de R) est la valeur reçue sur l’entrée du haut, et y (opérande à droite de R) est la valeur reçue sur l’entrée du bas. La relation binaire testée par un comparateur est indiquée sur les figures par le symbole correspondant.
Toujours par convention, un résultat fourni par un comparateur primaire est dit positif si la relation binaire R qu’il examine est vérifiée par des valeurs qu’il reçoit en entrée, et est dit négatif dans le cas contraire. Par exemple, un résultat positif est représenté par la valeur 1 , tandis qu’un résultat négatif est représenté par la valeur 0 (zéro).
Dans le premier mode de réalisation illustré sur la figure 1 , la relation binaire R vérifiée par chaque comparateur primaire est une relation d’ordre strict (R pouvant ainsi être < ou >).
Les comparateurs primaires sont agencés pour recevoir en entrée la valeur PO de la donnée de référence d’entrée et la valeur d’une des autres données d’entrée (ici, P1 ou P2 puisque n=3). Autrement dit, ces comparateurs sont configurés pour générer un résultat de comparaison de la valeur PO de la donnée de référence avec la valeur d’une autre donnée d’entrée du jeu.
La pluralité de comparateurs comprend ainsi :
• un premier groupe de n-1 comparateurs fournissant un résultat indiquant si la valeur PO de la donnée de référence est strictement supérieure à la valeur d’une autre donnée d’entrée ou pas (sur la figure 2, ces comparateurs sont affublés du symbole >) ; et
• un deuxième groupe de n-1 comparateurs fournissant un résultat indiquant si la valeur PO de la donnée de référence est strictement inférieure à la valeur d’une autre donnée d’entrée ou pas (sur la figure 2, ces comparateurs sont affublés du symbole <)·
Dans le module de traitement 1 illustré en figure 1 et pour lequel on a N=3, les groupes sont constitués comme suit :
• le premier groupe de comparateurs de type > comprend deux comparateurs dont o un comparateur vérifiant si PO > P1 ou non et o un comparateur vérifiant si PO > P2 ou non,
• le deuxième groupe de comparateurs de type < comprend deux comparateurs dont o un comparateur vérifiant si PO < P1 ou non et o un comparateur vérifiant si PO < P2 ou non.
Le module de traitement 1 comprend par ailleurs un premier additionneur, et un deuxième additionneur (désignés sur la figure 1 par le signe +).
Le premier additionneur est connecté aux sorties respectives des comparateurs du premier groupe. Le premier additionneur est configuré pour déterminer le nombre de données d’entrée autre que la donnée de référence d’entrée qui sont de valeur strictement inférieure à la valeur PO de la donnée de référence (étape a). Ce nombre déterminé est la sortie du premier additionneur.
Pour cela, le premier additionneur peut tout simplement initialiser un premier compteur à zéro, et incrémenter ce compteur d’un incrément égal à 1 chaque fois que le premier additionneur reçoit un résultat positif d’un comparateur appartenant au premier groupe.
Similairement, le deuxième additionneur est connecté aux sorties respectives des comparateurs du deuxième groupe. Le deuxième additionneur est configuré pour déterminer le nombre de données d’entrées autre que la donnée de référence d’entrée qui sont de valeur strictement supérieure à la valeur PO de la donnée de référence (étape c). Ce nombre déterminé est la sortie du deuxième additionneur.
Pour cela, le deuxième additionneur peut tout simplement initialiser un deuxième compteur à zéro, et incrémenter ce deuxième compteur d’un incrément égal à 1 chaque fois que le deuxième additionneur reçoit un résultat positif d’un comparateur appartenant au deuxième groupe.
Le module de traitement 1 comprend par ailleurs un premier comparateur secondaire et un deuxième comparateur secondaire (situés à droite des additionneurs).
Les deux comparateurs secondaires sont des comparateurs se bornent à vérifier une relation d’ordre strict, tout comme les comparateurs primaires. Plus précisément, le premier comparateur secondaire (en haut à droite de la figure 1 ) est configuré pour vérifier si le nombre déterminé par le premier additionneur est strictement inférieur au premier seuil Sa (étape b) du procédé). Si oui, le premier comparateur génère un résultat positif sur sa sortie, par exemple représenté par la valeur 1 ; sinon, le premier comparateur génère un résultat négatif sur sa sortie, par exemple représenté par la valeur 0.
Similairement, le deuxième comparateur secondaire (en bas à droite de la figure 1 ) est configuré pour vérifier si le nombre déterminé par le deuxième additionneur est strictement inférieur au deuxième seuil Sb prédéterminé (étape d) du procédé). Si oui, le premier comparateur génère un résultat positif sur sa sortie, par exemple représenté par la valeur 1 ; sinon, le premier comparateur génère un résultat négatif sur sa sortie, par exemple représenté par la valeur 0.
Pour produire la donnée de sortie V0, le module de traitement 1 peut comprendre une porte de type ET logique prenant en entrée les résultats fournis par les comparateurs secondaires. Dans ce cas, lorsque V0 vaut 1 , V0 indique que la valeur de la donnée de référence est un fractile prédéterminé du jeu de n données d’entrée.
Le fractile testé par le module de traitement 1 dépend des valeurs assignées aux deux seuils Sa, Sb.
Si le premier seuil et le deuxième seuil valent chacun (n+1 )/2, n étant impair, alors le fractile testé par le module de traitement 1 est une médiane ; autrement dit, le module de traitement 1 a alors pour fonction de tester si la valeur PO est ou non la médiane des valeurs des n données d’entrée.
En variante, on peut avoir Sa=n et Sb=1. Dans ce cas, le fractile testé est la valeur maximale parmi les valeurs des n données d’entrée. Autrement dit, le module a pour fonction de déterminer si la valeur de référence est la donnée d’entrée du jeu de valeur maximale.
Dans une autre variante, on peut avoir Sa=1 et Sb=n. Dans ce cas, le fractile testé est la valeur minimale parmi les valeurs des n données d’entrée. Autrement dit, le module a pour fonction de déterminer si la valeur de référence est la donnée d’entrée du jeu de valeur maximale.
Le fonctionnement du module de traitement 1 peut être illustré par deux exemples (on suppose dans ces exemples que Sa = Sb = (n+1)/2, donc que le fractile testé est la médiane).
Supposons dans un premier exemple que PO > P1 > P2. Le module de traitement 1 procède alors comme suit : • Les deux comparateurs du premier groupe fournissent chacun un résultat positif au premier additionneur, si bien que le premier compteur atteint la valeur 2 après avoir été incrémenté deux fois. La valeur du premier compteur est transmise au premier comparateur secondaire, lequel constate que cette valeur n’est pas strictement inférieure au premier seuil (la valeur du premier compteur est en effet égale au premier seuil valant (n+1 )/2). Le premier comparateur secondaire génère donc un résultat négatif.
• Par ailleurs, les deux comparateurs du deuxième groupe fournissent chacun un résultat négatif au deuxième additionneur, si bien que le deuxième compteur reste à zéro. La valeur du deuxième compteur est transmise au premier comparateur secondaire, lequel constate que cette valeur est bien strictement inférieure au deuxième seuil (zéro est bien strictement inférieur à (n+1 )/2). Le deuxième comparateur secondaire génère donc un résultat positif.
• Comme les deux résultats générés par les deux comparateurs secondaires ne sont pas tous les deux positifs, le module de traitement 1 parvient à la conclusion que la valeur PO n’est pas une médiane.
Supposons à présent que P1 < PO < P2. Le module de traitement 1 procède comme suit :
• Seul un des comparateurs du premier groupe fournit un résultat positif au premier additionneur, si bien que le premier compteur atteint la valeur 1 après avoir été incrémenté une fois. La valeur du premier compteur est transmise au premier comparateur secondaire, lequel constate que cette valeur est bien strictement inférieure au premier seuil (1 < 2). Le premier comparateur secondaire génère donc un résultat positif.
• Similairement, seul un des comparateurs du deuxième groupe fournit un résultat positif au deuxième additionneur, si bien que le deuxième compteur atteint la valeur 1 après avoir été incrémenté une fois. La valeur du deuxième compteur est transmise au deuxième comparateur secondaire, lequel constate que cette valeur est bien strictement inférieure au premier seuil (1 < 2). Le deuxième comparateur secondaire génère donc un résultat positif.
• Comme les résultats générés par les deux comparateurs secondaires sont tous les deux positifs, le module de traitement 1 parvient à la conclusion que la valeur PO est bien la médiane des valeurs PO, P1 , P2.
Il est à noter que le module de traitement 1 fonctionne correctement même dans le cas où plusieurs des n données d’entrée ont des valeurs égales, en particulier plusieurs valeurs égales au fractile testé. Est illustré en figure 2 un module de traitement 2 selon un deuxième mode de réalisation. Ce deuxième mode de réalisation diffère du premier mode de réalisation par les caractéristiques suivantes.
Les comparateurs primaires du premier groupe ne vérifient pas une relation d’ordre strict, mais se bornent à vérifier une relation d’égalité, ce qui présente l’avantage de permettre une réduction de leur surface. Ainsi, le résultat fourni par un comparateur primaire du premier groupe est positif si les deux valeurs comparées sont égales, et ce résultat est négatif dans le cas contraire (si les deux valeurs comparées sont différentes).
Dans le module de traitement illustré en figure 2 et pour lequel on a n=3, les groupes de comparateurs primaires sont constitués comme suit :
• le premier groupe de comparateurs primaires de type = comprend deux comparateurs dont o un comparateur vérifiant si PO = P1 ou non et o un comparateur vérifiant si PO = P2 ou non,
• le deuxième groupe de comparateurs primaires de type < comprend deux comparateurs dont o un comparateur vérifiant si PO < P1 ou non et o un comparateur vérifiant si PO < P2 ou non.
Ainsi, dans le module de traitement 2, il existe deux comparateurs qui comparent la valeur de la donnée de référence et la valeur d’une même autre donnée d’entrée, mais les comparaisons mises en oeuvre par ces deux comparateur reposent sur des relations binaires différentes, si bien que ces deux comparateurs fournissent des résultats donnant des informations de nature différente : l’un de ces résultats indique si la valeur de la donnée de référence est égale ou non à l’autre valeur, et l’autre indique si une relation d’ordre strict est vérifiée par la valeur de donnée de référence et la valeur de l’autre donnée d’entrée.
Le module de traitement 2 est configuré pour croiser ces deux résultats de natures différentes, pour déterminer si l’autre donnée doit être comptabilisée par le premier additionneur.
En pratique, ce croisement est implémenté au moyen d’une porte additionnelle de type NON-OU (NOR en anglais) logique prenant en entrée les deux résultats et dont la sortie est reliée au premier additionneur.
Pour illustrer la réduction de surface que l’on peut obtenir dans le module de traitement 2, comparativement au module de traitement 1 , prenons l’exemple de valeurs codées sur 16 bits. Un comparateur vérifiant une relation d’ordre strict (équivalente à une soustraction en termes de complexité) pourra alors être implémenté à l’aide de 16 LUT6. Un comparateur se bornant à vérifier une égalité pourra quant à lui être implémenté à l’aide de 16/3 LUT6 (une égalité est une comparaison bit à bit + un arbre de ces comparaisons). Le coût nécessaire pour croiser deux résultats est de 7 LUT, mais reste suffisamment faible pour permettre de réduire la surface globale du module de traitement 2 par rapport au module de traitement 1.
Est illustré en figure 3 un module de traitement 3 selon un troisième mode de réalisation. Ce troisième mode de réalisation diffère du premier mode de réalisation par les caractéristiques suivantes.
Les comparateurs primaires du deuxième groupe ne vérifient pas une relation d’ordre strict, mais se bornent à vérifier une relation d’égalité, ce qui présent l’avantage de permettre une réduction de leur surface. Ainsi, le résultat fourni par un comparateur primaire du deuxième groupe est positif si les deux valeurs comparées sont égales, et ce résultat est négatif dans le cas contraire (si les deux valeurs comparées sont différentes).
Dans le module de traitement 3 illustré en figure 3 pour lequel on a n=3, les groupes de comparateurs primaires sont constitués comme suit :
• le premier groupe de comparateurs primaires de type > comprend deux comparateurs dont o un comparateur vérifiant si PO > P1 ou non et o un comparateur vérifiant si PO > P2 ou non,
• le deuxième groupe de comparateurs primaires de type = comprend deux comparateurs dont o un comparateur vérifiant si PO = P1 ou non et o un comparateur vérifiant si PO = P2 ou non.
Tout comme dans le deuxième mode de réalisation, il existe dans le troisième mode de réalisation deux comparateurs qui comparent la valeur de la donnée de référence et la valeur d’une autre donnée d’entrée, mais les comparaisons mises en oeuvre par ces deux comparateur reposent sur des relations binaires différentes, si bien que ces deux comparateurs fournissent des résultats donnant des informations de nature différente : l’un de ces résultats indique si la valeur de la donnée de référence est égale ou non à l’autre valeur, et l’autre indique si une relation d’ordre strict est vérifiée par la valeur de donnée de référence et la valeur de l’autre donnée d’entrée. Le module de traitement selon le deuxième mode de réalisation est configuré pour croiser ces deux résultats de natures différentes, pour déterminer si l’autre donnée doit être comptabilisée par le deuxième additionneur.
En pratique, ce croisement est implémenté au moyen d’une porte additionnelle de type NON-OU (NOR en anglais) logique prenant en entrée les deux résultats et dont la sortie est reliée au deuxième additionneur.
Ce troisième mode de réalisation a les mêmes avantages de réduction de surface que le deuxième mode de réalisation.
En référence à la figure 4, un dispositif de filtrage 4 comprend une pluralité de modules de traitement 1. Chacun de ces modules 1 est conforme au premier mode de réalisation. Il est toutefois entendu que chacune de ces modules 1 pourrait être remplacé par un module de traitement 2 selon le deuxième mode de réalisation ou un module de traitement 3 selon le troisième mode de réalisation.
Le dispositif de filtrage 4 comprend n entrées, une pour chaque donnée d’entrée.
Chacun des modules de traitement 1 du dispositif de filtrage 4 est associé en propre à l’une des données d’entrée. Chaque module de traitement 1 est configuré pour traiter comme donnée de référence la donnée d’entrée qui lui est associée. Le nombre de modules de traitement 1 du dispositif de filtrage 4 est ainsi au plus égal à n. Le module de traitement traitant la donnée de valeur Pi comme donnée de référence, une donnée de sortie Vi qui indique si Pi est ou non le fractile prédéterminé.
Les modules de traitement 1 du dispositif de filtrage 4 sont agencés en parallèle, au sens où ils sont configurés pour fonctionner en parallèle.
Le dispositif de filtrage 4 représenté en figure 4, et pour lequel on a n=3 comprend ainsi trois modules de traitement 1 , dont :
• un premier module de traitement 1 traitant la première donnée de valeur PO comme donnée de référence, de sortie à produire la donnée de sortie VO qui indique si PO est le fractile recherché
• un deuxième module de traitement 1 traitant la deuxième donnée de valeur P1 comme donnée de référence, de sorte à produire une donnée de sortie V1 indiquant si la P1 est le fractile recherché,
• un troisième module de traitement 1 traitant la troisième donnée de valeur P2 comme donnée de référence, de sorte à produire une donnée de sortie V2 indiquant si la P1 est le fractile recherché. Le nombre total de comparateurs primaires est au plus égal à 2n(n-1 ), soit 12 si n=3.
Le dispositif de filtrage 4 comprend par ailleurs un module de génération de fractile 6. Le module de génération 6 est connecté aux sorties respectives des différents modules de traitements 1 agencés en parallèle, si bien que ce module de génération 6 reçoit n données Vi.
Le module de génération 6 est configuré pour sélectionner la valeur d’une des n données d’entrée comme donnée de sortie sur la base de ces données Vi.
Dans le mode de réalisation illustré sur la figure 4, le module de génération 6 présente une structure utilisant seulement des opérateurs ET et OU bit à bit. Plus précisément, le module de sélection comprend une pluralité de portes de type ET logique bit a bit, chacune de ces portes prenant en entrée l’une des données Vi, et par ailleurs la donnée Pi associée. Le module de sélection comprend par ailleurs une porte de type OU logique bit à bit, prenant en entrée les sorties respectives des portes de type ET logique bit à bit. Cette porte fournit en sortie le fractile recherché par le dispositif de filtrage 4 (donc, par exemple la valeur médiane des valeurs des n données d’entrée). Cette structure est avantageuse car ne contient pas de logique à priorité. Elle utilise donc moins de niveaux logiques qu’une structure contenant une telle logique à priorité, permettant ainsi un potentiel de montée en fréquence plus important.
En variante, le module de génération 6 peut comprendre un encodeur à priorité des indicateurs de fractile, suivi d’un multiplexeur.
On a représenté en figure 5 un dispositif de filtrage 5 selon un deuxième mode de réalisation. Ce dispositif de filtrage 5 diffère du dispositif de filtrage 4 par le fait que son nombre de modules de traitements 1 est strictement inférieur à n, de telle sorte de telle sorte qu’au moins une des n données d’entrée, dite donnée restante, n’est pas traitée comme donnée de référence par un quelconque des modules de traitement 1.
Le dispositif de filtrage 5 comprend un module complémentaire 7 configuré pour générer une donnée de sortie indiquant si la donnée restante est le fractile recherché, sur la base des données de sortie générées par les modules de traitements 1.
Le nombre de modules de traitement est par exemple égal à n-1 , si bien qu’il n’y a qu’une seule donnée d’entrée restante.
Dans le mode de réalisation particulier illustré en figure 5, le nombre de modules de traitement 1 est égal à n-1 , soit 2 lorsque n=3. En fait, si toutes les autres données de sortie indiquent des résultats négatifs (c’est-à-dire que les données de référence correspondantes ne sont pas le fractile recherché), alors, par élimination, la donnée d’entrée pour laquelle il n’a pas été associé de module de traitement (ici, P2) est forcément le fractile recherché.
En pratique, le module complémentaire peut être une porte additionnelle de type NON-OU (NOR en anglais) logique prenant en entrée les sorties des modules de traitements Vi et dont la sortie au module de génération de fractile 6.
Ce mode de réalisation est avantageux car la surface requise pour le module complémentaire est inférieure à celle d’un module de traitement 1. La surface générale d’implémentation du dispositif est ainsi réduite.
Les dispositifs de filtrage 4, 5 trouvent avantageusement application dans le domaine du traitement d’image. En référence à la figure 6, un dispositif de traitement d’image 10 comprend un module de sélection de pixels 12, au moins un dispositif de filtrage 4 agencé en sortie du module de sélection de pixels 12, et un module de génération d’image 14 agencé en sortie du dispositif de filtrage 4. Bien entendu, le dispositif 4 peut être remplacé par le dispositif 5 dans le dispositif de traitement d’image 10.
De façon générale, le dispositif de traitement d’image 10 a pour fonction de produire une image de sortie filtrée à partir d’une image d’entrée, ce filtrage étant appliqué par le dispositif de filtrage 4.
Le module de sélection de pixels 12 est configuré pour recevoir une image d’entrée A. L’image d’entrée A comprend pluralité de pixels, chaque pixel ayant une position qui lui est propre dans l’image d’entrée (cette position se présentant typiquement sous la forme d’un couple d’indices de ligne et de colonne). Chaque pixel de l’image d’entrée A a par ailleurs au moins une valeur qui renseigne sur sa couleur. Dans ce qui suit, on va supposer dans un premier temps que chaque pixel de l’image d’entrée A a une seule valeur, qui indique un niveau de gris.
Le module de sélection de pixels 12 est configuré pour sélectionner dans l’image d’entrée A un voisinage de n pixels associé à un pixel de l’image A dit pixel principal.
Par exemple, dans le cas où n=3, ce voisinage comprend typiquement le pixel principal, et deux pixels voisins du pixel principal. Les deux pixels voisins sont typiquement situés de part et d’autre du pixel principal (sur la même colonne ou sur la même ligne dans l’image d’entrée A). Dans un autre mode de réalisation dans lequel n=9, le voisinage forme un carré de pixels centré sur le pixel principal, et comprenant les huit pixels voisins du pixel principal.
Le dispositif de filtrage 4 est agencé pour recevoir en entrée les valeurs respectives du voisinage de n pixels sélectionné par le module de sélection de pixels 12. En d’autres termes, les données d’entrée traitées par le dispositif de filtrage 4 sont ici les n pixels qui constituent le voisinage de pixels sélectionné par le module de sélection de pixels 12.
Le dispositif de filtrage 4 fournit en sortie une valeur de pixel filtrée V, associée au pixel principal.
Le dispositif de traitement d’image 10 est configuré pour répéter les étapes qui précèdent sur plusieurs itérations successives, chaque itération prenant en entrée un nouveau pixel de l’image d’entré considéré comme pixel principal par le module de sélection de pixels 12.
A l’issue de ces itérations successives, le dispositif de filtrage produit autant de valeurs de pixels filtrées V que de pixels d’entrée successivement traités comme pixels principaux par le module de sélection de pixels.
Le module de génération 14 est configuré pour générer une image de sortie B à partie de toutes ces valeurs de pixel filtrées V fournies par le dispositif de filtrage 4.
Dans un mode de réalisation particulièrement avantageux du dispositif de traitement d’image 10, n est impair et Sa=Sb=(n+1 )/2 (auquel cas le dispositif de filtrage 4 agit comme un filtre médian). En effet, ce mode de réalisation permet d’éliminer dans l’image d’entrée A des valeurs de pixels aberrantes.
Dans ce qui précède, il a été fait l’hypothèse que le dispositif de traitement d’image 10 traite une image d’entrée en niveaux de gris. En variante, le dispositif de traitement d’image 10 peut être configuré pour traiter des images d’entrée en couleur. Dans ce cas, chaque pixel de l’image d’entrée peut comprendre non pas une unique valeur mais un k-uplet de composantes couleur, le k-uplet étant caractéristique de la couleur du pixel. Ce k-uplet est par exemple un triplet de composantes rouge, vert et bleu. Autrement dit, l’image d’entrée est une superposition de k images élémentaire, chaque image élémentaire se rapportant une des k composantes de l’image d’entrée A.
Le module de sélection de pixels 12 est configuré pour fournir au dispositif de filtrage les n valeurs de pixels d’un voisinage appartenant à la même composante couleur. Le dispositif de filtrage peut ainsi être sollicité k fois, une fois par composante, permettant ainsi au module de génération de générer une image de sortie en couleur. En variante, le dispositif de traitement d’image 10 peut comprendre k dispositifs de filtrage 4 agencés en parallèles, chaque dispositif de filtrage 4 étant associé à une des k composantes de l’image d’entrée.
Est représenté en figure 7 un troisième mode de réalisation de dispositif de filtrage 11.
Le dispositif de filtrage 11 comprend tous les composants du dispositif de filtrage 4, en particulier les trois modules de traitement 1 discutés précédemment, visant à tester si différentes données d’entrée sont un fractile prédéterminé du jeu, que l’on appelle dans ce qui suit premier fractile, en s’aidant pour cela des seuils Sa et Sb.
Le dispositif de filtrage 11 comprend par ailleurs trois modules de traitement supplémentaire ayant la même structure que les modules du dispositif 4, mais testant un deuxième fractile différent du premier fractile, à l’aide de seuils Sa’ et Sb’ ayant des valeurs potentiellement différentes des seuils Sa et Sb.
Ces trois modules de traitement supplémentaires sont :
• un quatrième module de traitement 1 traitant la première donnée de valeur PO comme donnée de référence, de sortie à produire la donnée de sortie V’0 qui indique si PO est le deuxième fractile recherché
• un cinquième module de traitement 1 traitant la deuxième donnée de valeur P1 comme donnée de référence, de sorte à produire une donnée de sortie V’1 indiquant si la P1 est le deuxième fractile recherché,
• un sixième module de traitement 1 traitant la troisième donnée de valeur P2 comme donnée de référence, de sorte à produire une donnée de sortie V’2 indiquant si la P1 est le deuxième fractile recherché.
Le dispositif de filtrage 11 comprend les mêmes n entrées que le dispositif de filtrage 4. En revanche, il comprend deux sorties et non une seule : la première sortie, déjà présente dans le dispositif de filtrage 4, délivre le premier fractile, et la deuxième sortie délivre le deuxième fractile. Cette deuxième sortie est délivrée par un module de génération de fractile supplémentaire ayant par exemple une structure identique au module 6 représenté en figure 4.
Plusieurs modules de traitement utilisent les même comparateurs primaires et les mêmes additionneurs :
• le premier module de traitement et le quatrième module de traitement,
• le deuxième module de traitement et le cinquième module de traitement,
• le troisième module de traitement et le sixième module de traitement On constate que plusieurs composants ont ici été mutualisés pour obtenir plusieurs fractiles différents. Ce principe est bien entendu généralisable à plus que deux fractiles.
On peut également considérer que, dans ce mode de réalisation, un module de traitement 1 est étendu pour mettre en oeuvre les étapes additionnelles suivantes :
- b') comparer la somme calculée à l’étape a) avec un troisième seuil (Sa’),
- d’) comparer la somme calculée à l’étape c) avec un quatrième seuil (Sb’),
- e’) générer une donnée de sortie indiquant si la donnée de référence est un deuxième fractile prédéterminé de fractiles différent du fractile prédéterminé de l’étape e), seulement si les deux conditions suivantes sont satisfaites : la somme calculée à l’étape a) est inférieure, strictement ou non, au troisième seuil (Sa’) et la somme calculée à l’étape c) est inférieure, strictement ou non, au quatrième seuil (Sb’).
Pour que les deux fractiles testés par ce module étendu soient différents, la paire de seuils (Sa’, Sb’) est différente de la paire de seuils (Sa, Sb).
Optimisation par symétrie
Dans le dispositif de filtrage 4 représenté en figure 4, le nombre total de comparateurs primaires nécessaires pour obtenir les n données Vi qui sont ensuite passées en entrée du module de sélection de sortie est relativement important.
Pour réduire ce nombre, et par conséquent la surface totale du dispositif de filtrage 4, il est possible de faire en sorte qu’un comparateur primaire soit non seulement sollicité pour produire une donnée de sortie Vi associée à une donnée d’entrée Pi, mais également pour produire une donnée de sortie Vj associée à une donnée d’entrée Pj différente.
Cette optimisation est dite par symétrie car se fonde sur le caractère symétrique des comparaisons effectuées : x strictement plus grand que y est équivalent à y strictement plus petit que x .
Est illustré en figure 8 un dispositif de filtrage 8 optimisé par symétrie, dans lequel on a n=3. Ce dispositif de filtrage 8 comprend des composants du même type que ceux du dispositif de filtrage 4, mais diffère de ce dernier par un nombre inférieur de comparateurs primaires.
Prenons par exemple le cas du premier module de traitement associé à la première donnée d’entrée de valeur PO et produisant la donnée V0, et du deuxième module de traitement associé à la deuxième donnée d’entrée de valeur P1. Un comparateur primaire configuré pour comparer les valeurs PO, P1 respectives de la première donnée d’entrée et de la deuxième donnée d’entrée fait partie du premier groupe de comparateurs du premier module de traitement, et fait en même temps partie du deuxième groupe de comparateurs du deuxième module de traitement. Autrement dit, ce comparateur est configuré pour comparer PO et P1 et pour fournir un résultat qui est ensuite exploité par deux additionneurs :
• l’additionneur du premier module de traitement qui est configuré pour mettre en oeuvre l’étape a), et
• l’additionneur du deuxième module de traitement configuré pour mettre en oeuvre l’étape c).
Il existe par ailleurs un autre comparateur primaire configuré pour comparer les valeurs PO, P1 respectives de la première donnée d’entrée et de la deuxième donnée d’entrée, faisant partie du deuxième groupe de comparateurs du premier module de traitement, et fait en même temps partie du premier groupe de comparateurs du deuxième module de traitements. Autrement dit, cet autre comparateur est configuré pour comparer PO et P1 et pour fournir un résultat qui est ensuite exploité par deux additionneurs :
• l’additionneur du premier module de traitement qui est configuré pour mettre en oeuvre l’étape c), et
• l’additionneur du deuxième module de traitement configuré pour mettre en oeuvre l’étape a).
En définitive, le premier module de traitement et le deuxième module de traitement ont les deux comparateurs qui précèdent en commun, et ces deux comparateurs en commun ont ceci de particulier qu’ils comparent les valeurs respectives des deux données associées à ces deux modules de traitement.
Ce principe peut être généralisé à chaque paire de modules de traitements présents dans le dispositif de filtrage. Il est ainsi possible de diviser par deux le nombre total de comparateurs primaires, ce qui permet de réduire encore la surface d’implémentation du dispositif de filtrage.
Dans le mode de réalisation illustré en figure 8, dans lequel on a n=3, les modules supprimés par cette optimisation par symétrie apparaissent grisés. Le nombre total de comparateurs primaire est réduit à 6 (au lieu de 12 dans le mode de réalisation illustré en figure 4).
Il est entendu que le même type d’optimisation par symétrie peut être apporté dans des dispositifs de filtrage comprenant des modules de traitements 2 conformes au deuxième mode de réalisation, ou des modules de traitements 3 conformes au troisième mode de réalisation.
Il est entendu que le dispositif de filtrage 8 optimisé par symétrie peut remplacer le dispositif de filtrage 4 dans le dispositif de traitement d’image 10.
Optimisation par somme glissante
Le déroulement des étapes a) et c) mises en oeuvre par l’un quelconque des modules de traitement 1 , 2, 3 peut également être optimisé lorsque le module de traitement concerné est amené à fonctionner de manière répétée par itérations successives, sur des jeux de données d’entrée se chevauchant mutuellement.
Ce type d’optimisation, que l’on appelle optimisation par somme glissante, est notamment possible lorsque le module de traitement selon l’une de ces modes de réalisation fait partie d’un dispositif de filtrage faisant lui-même partie d’un dispositif de traitement d’image 10 tel que celui représenté en figure 6. En effet, le module de sélection de pixels 12 peut être configuré pour opérer un balayage de l’image d’entrée A, de telle sorte que le voisinage de n pixels sélectionné au cours d’une itération courante et le voisinage de n pixels sélectionné au cours d’une itération précédente se chevauchent. Les deux voisinages sont par exemple décalés d’un pixel horizontalement ou verticalement (ce qui veut dire que les deux pixels successivement traités comme pixel de référence par le module de sélection de pixels 12 au cours de ces deux itérations successives sont mutuellement voisins).
Par convention, on appelle « jeu courant » un jeu de n données d’entrée traité par un module de traitement du dispositif de filtrage au cours d’une itération courante, et « jeu précédent » un jeu de n données d’entrée traité par le même module de traitement lors d’une itération précédente.
Le jeu courant diffère du jeu précédent en ce qu’il comprend au moins une nouvelle donnée d’entrée qui n’était pas présente dans le jeu précédent, et en ce qu’il ne comprend pas au moins une ancienne donnée qui était pourtant présente dans le jeu précédent. Le jeu courant a toutefois au moins une donnée d’entrée en commun avec le jeu précédent.
On a représenté en figure 9 une partie de l’image d’entrée A, et deux voisinages de pixels (en pointillés) sélectionnés par le module de sélection de pixels 12 au cours de deux itérations successives, dans un mode de réalisation dans lequel on a n=9. Dans ce mode de réalisation, il y a trois nouvelles données d’entrée, six données en commun, et trois anciennes données. Dans ce qui suit, on suppose que l’itération courante et l’itération précédente traitent la même donnée d’entrée comme donnée de référence. Il est dans ce cas possible d’optimiser le fonctionnement interne du module de traitement mettant en oeuvre ces deux itérations. On prendra l’exemple du module de traitement selon le premier mode de réalisation représenté en figure 1 , mais ce qui suit est également applicable aux modes de réalisations des figures 2 et 3.
Pour rappel, sont calculés au cours de l’étape a) le nombre de données d’entrée autres que la donnée de référence qui ont des valeurs strictement inférieures à la valeur de la donnée de référence, et au cours de l’étape c) le nombre de données d’entrées autres que la donnée de référence qui ont des valeurs strictement supérieures à la valeur de la donnée de référence. Dans les modes de réalisations représentés sur les figures 1 , 2 et 3, ces étapes a) et c) comprennent l’initialisation d’un premier compteur et d’un deuxième compteur à zéro.
Pour optimiser la mise en oeuvre de l’étape a) au cours de l’itération courante, la somme calculée lors de l’étape a) de l’itération précédente est avantageusement sauvegardée. L’étape a) de l’itération courante comprend alors les étapes suivantes : a1 ) initialiser le premier compteur à ladite somme sauvegardée, a2) pour chaque nouvelle donnée du jeu courant, incrémenter le premier compteur de un seulement si la valeur de la nouvelle donnée est strictement inférieure à la valeur de la donnée de référence, a3) pour chaque ancienne donnée, décrémenter le premier compteur de un seulement si la valeur de l’ancienne donnée est strictement inférieure à la valeur de la donnée de référence.
Similairement, pour optimiser la mise en oeuvre de l’étape c) au cours de l’itération courante, la somme calculée lors de l’étape c) de l’itération précédente est avantageusement sauvegardée. L’étape c) de l’itération courante comprend alors les étapes suivantes : c1 ) initialiser le deuxième à ladite somme sauvegardée, c2) pour chaque nouvelle donnée du jeu courant, incrémenter le deuxième compteur de un seulement si la valeur de la nouvelle donnée est strictement supérieure à la valeur de la donnée de référence, c3) pour chaque ancienne donnée, décrémenter le deuxième compteur de un seulement si la valeur de l’ancienne donnée est strictement supérieure à la valeur de la donnée de référence. Dans le mode de réalisation présenté ci-dessus, les étapes a2), a3), c2) et c3) utilisent des relations d’ordre strictes. Toutefois, ceci n’est pas nécessaire pour mettre en oeuvre une optimisation par somme glissante.
Dans un autre mode de réalisation, les données d’entrée traitées par un même module de traitement 1 , 2, 3 comme donnée de référence au cours de l’itération courante et au cours de l’itération précédente sont différentes. Dans ce cas, l’optimisation par somme glissante implique une communication entre des modules de traitements différents du dispositif de filtrage. En effet, les étapes a1 -a3) ou c1 -3) mises en oeuvre par un module de traitement se fondent alors sur une somme sauvegardée par un autre module de traitement.
Ces optimisations par somme glissante sont avantageuses car permettent de réduire le nombre de comparaisons et d’additions mises en oeuvre par le module de traitement au cours des étapes a) et c) de l’itération courante.
Pour mettre en oeuvre de telles optimisations, on peut utiliser des additionneurs ternaires, ayant trois entrées au lieu de deux comme illustré sur les figures 1 à 3 (la troisième entrée étant utilisée pour recevoir la valeur sauvegardée lors de l’itération précédente). De tels additionneurs peuvent être implémentées à l’aide d’une LUT6 par bit.
Optimisation par propagation
Il est également possible, en cas de chevauchement entre deux jeux de données traités séquentiellement, de limiter le nombre total de comparaisons effectuées par les comparateurs primaires du dispositif de filtrage 4 ou 8, voire du module de traitement 1 , 2 ou 3.
Cette optimisation, dite par propagation, repose sur l’idée que deux données d’entrée en commun entre un jeu courant et un jeu précédent n’ont pas besoin d’être comparées deux fois, une fois lors de l’itération précédente et une fois encore au cours de l’itération courante. Au lieu de cela, le résultat d’une comparaison entre deux valeurs réalisées au cours de l’itération précédente et sauvegardée, puis réutilisé par un additionneur au cours de l’itération courante, s’il s’avère que ces deux valeurs se rapportent à des données d’entrée qui sont encore présentes dans le jeu traité au cours de l’itération courante.
Par exemple, supposons que l’un des modules de traitement représentés en figures 1 , 2 ou 3, dans lequel on a n=3, a traité trois données d’entrée ayant les valeurs PO, P1 , P2 au cours d’une itération précédente, et que le dispositif de filtrage doive traiter au cours d’une itération courante un jeu de données d’entrée ayant une nouvelle donnée d’entrée de valeur P3, mais ne comprenant pas la donnée d’entrée de valeur PO (qui est donc une ancienne valeur). Autrement dit, PO devient P1 , P1 devient P2, et P2 devient P3.
Dans ce cas, il peut être sauvegardé au cours de l’itération précédente le résultat d’une comparaison effectuée entre les valeurs P1 et P2 ; ce résultat sauvegardé peut ensuite être utilisé par un additionneur au cours de l’itération courante.
Il est à noter que cette optimisation par propagation n’est pas limitée au cas d’une itération précédent immédiatement l’itération courante, mais peut être généralisé à plusieurs itérations antérieures, plus ou moins anciennes. On peut en effet trouver dans des itérations plus anciennes des comparaisons déjà effectuées, et pouvant être réutilisées pour l’itération courante.
On a représenté en figure 10 une partie de l’image d’entrée A, dans un mode de réalisation dans lequel on a n=9, deux voisinages de pixels (en pointillés fins) sélectionnés par le module de sélection de pixels 12 au cours de deux itérations antérieures distinctes dits jeux précédents, et un voisinage de pixels (dont les pixels sont hachurés) sélectionné par le module de sélection de pixels 12 au cours d’une itération courante dit jeu courant. Dans ce mode de réalisation, il y a une nouvelle donnée, quatre données partiellement communes, quatre données complètement communes et six anciennes données. On entend par donnée partiellement commune des données du jeu courant qui appartiennent à un seulement l’un des jeux précédents, et par données complètement communes des données du jeu courant qui appartiennent aux deux jeux précédents.
Lors des itérations précédentes, le dispositif de filtrage 4, 8 a déjà produit les résultats des comparaisons entre les valeurs des données complètement communes, les résultats des comparaisons entre les valeurs des données partiellement communes et les valeurs des données complètement communes et les résultats des comparaisons entre les valeurs données partiellement communes qui appartiennent au même jeu précédent. Selon l’optimisation par propagation ces résultats ont été sauvegardés.
Au contraire les comparaisons entre les valeurs des données partiellement communes qui proviennent respectivement de l’un et de l’autre des deux jeux précédents n’ont pas été effectuées par le dispositif de filtrage 4, 8 lors d’une itération précédente (4 comparaisons si n = 9). De même aucune comparaison n’a été effectuée entre la valeur de la nouvelle donnée et celles des autres données du jeu courant (8 si n=9).
Si n=9, le dispositif de filtrage doit donc effectuer 12 comparaisons lors de l’étape courante avec l’optimisation par propagation contre 72 (9 fois 8) comparaisons sans l’optimisation par propagation. Cette optimisation par propagation présente donc l’avantage de réduire grandement le nombre de comparaisons à effectuer lors d’une l’itération courante, le dispositif de filtrage 4, 8 se limitant à effectuer les comparaisons dont les résultats n’ont pas été produits précédemment.
Autres variantes de réalisation de test sur un fractile
Dans les modes de réalisation décrits précédemment, les conditions vérifiées à l’étape e) se fondent sur une relation d’ordre stricte (<) : ainsi, il est vérifié si le nombre obtenu à l’étape a) est strictement inférieur au premier seuil Sa, et similairement si le nombre obtenu à l’étape c) est strictement inférieur au seuil Sb. Par ailleurs, la somme des seuils Sa et Sb vaut n+1 .
En variante, il peut être prévu qu’au moins une des deux conditions vérifiées à l’étape e) se fonde sur une relation d’ordre non strict (<). Dans ce cas, la somme des seuils Sa et Sb pourra être égale à n-1 (dans le cas où les deux conditions utilisent la relation d’ordre <) ou bien égale à n (dans le cas où une deux conditions utilise la relation d’ordre <, et l’autre utilise la relation d’ordre strict <). Cette variante permet d’obtenir la même donnée de sortie Vi que celle discutée précédemment.
Il est également possible de choisir les seuils Sa et Sb à des valeurs non entières.
En résumé, on a de manière générale ce qui suit : la somme des deux seuils est égale à n+p, avec p C [-1 , 1], p étant fonction de savoir si la somme calculée à l’étape a) doit être inférieure au premier seuil Sa de manière stricte et si la somme calculée à l’étape b) doit être inférieure au deuxième seuil Sb de manière stricte, pour que les deux conditions soient satisfaites. Autrement dit p est fonction du caractère strict ou non des relations d’ordres utilisées au cours de l’étape e).
Le fractile testé n’est pas nécessairement la médiane. Le fractile f testé par un module de traitement peut être quelconque (f étant un pourcentage, compris entre 0% et 100%). On peut alors ajuster les seuils comme suit : Sa = arrondi inférieur (f * n) + 1 et Sb = (n+1 ) - Sa (ou l’inverse, en calculant d’abord Sb = arrondi supérieur ((1 -f)*n) et Sa = (n+1 ) - Sb). Par arrondi supérieur, on entend arrondi inférieur + 1.
Généralisation à un test d’appartenance à un sous-ensemble de plusieurs fractiles
Les module de traitement 1 , 2, 3 discutés précédemment a pour fonction de tester si une donnée d’entrée de référence est un fractile spécifique, par exemple la médiane du jeu de n données d’entrée. Ce test peut être généralisé : il peut ainsi être testé par un module de traitement si la donnée de référence est un fractile du jeu de n données qui est inclus dans un sous-ensemble prédéterminé de fractiles. Par « sous-ensemble » de fractile, on veut signifier qu’il existe au moins un fractile n’appartenant à ce sous-ensemble. Autrement dit, le sous-ensemble de fractiles recherché n’est pas l’ensemble de tous les fractiles possibles, allant de 0 % à 100 %, mais est inclus dedans.
De préférence, au moins un parmi le minimum et le maximum du jeu de n données est exclu du sous-ensemble prédéterminé de fractiles. Autrement dit, le test appliqué par un module de traitement à une donnée de référence ayant une valeur maximale ou minimale dans le jeu de n données sera négatif.
Pour obtenir une telle généralisation, on peut régler les seuils Sa, Sb utilisés dans les modules 1 , 2 ou 3 à des valeurs telles que leur somme n’est pas nécessairement égale à n+p. Ces seuils définissent un sous-ensemble continu de plusieurs fractiles. Il est également envisageable de répliquer le dispositif tel que représenté en figure 7 pour obtenir un sous- ensemble de plusieurs fractile discontinu.
Dans une variante particulière, le sous-ensemble de plusieurs fractile est continu, comprend la médiane du jeu de n données, et comprend au moins un autre fractile.
Autres variantes de réalisation du module de génération
Dans les modes de réalisation illustrés, le module de génération 6 fonctionne comme un sélecteur. Il peut cependant être prévus d’autres modes de réalisations dans lequel la valeur produite en sortie de ce module ne correspond à aucune des valeurs respectives des n données d’entrée. Ce cas peut notamment se produire lorsque n est pair. Dans ce cas, il peut il y avoir deux médianes (une médiane basse et une médiane haute). Le module de génération 6 peut alors calculer la moyenne arithmétique de ces deux médianes.
Généralisation à des jeux de données d’entrée pondérés
Dans les modes de réalisation décrits précédemment, il est effectué un comptage de données d’entrée lors des étapes a) et c) (l’incrément utilisé pour incrémenter le premier compteur et le deuxième compteur vaut un).
Les n données d’entrée traitées par l’un quelconque des modes de réalisations décrits ci- dessus peuvent être toutefois pondérées. Dans ce cas, chaque donnée d’entrée est associée à un poids prédéterminé, venant en sus de la valeur de la donnée d’entrée. Les modifications sont alors apportées à un module de traitement. A l’étape a), il est calculé la somme des poids associés seulement aux données d’entrée autres que la donnée de référence qui ont des valeurs strictement inférieures à la valeur de la donnée de référence. Similairement, à l’étape c), il est calculé la somme des poids associés seulement aux données d’entrée autres que la donnée de référence qui ont des valeurs strictement supérieures à la valeur de la donnée de référence. Autrement dit, le premier compteur et le deuxième compteur sont incrémentés avec des poids, et non plus forcément avec un.
Par ailleurs, la somme du premier seuil Sa et du deuxième seuil Sb est choisie égale à s+p, s étant la somme des poids des n données d’entrée. Les modes de réalisations présentés précédemment en relation avec les figures constituent donc un cas particulier de ce principe général, dans lequel les poids respectifs des n données d’entrée sont tous égaux à un.
On peut par exemple noter les exemples particuliers suivantes de réalisation : Par ailleurs, dans l’application susmentionnée dans laquelle un module de traitement prend en entrée n pixels formant un voisinage de pixels dans l’image se rapportant à un pixel de référence, le poids associé à un pixel du voisinage peut être fonction de la position relative entre ce pixel et le pixel de référence. A titre d’exemple non limitatif, on peut choisir d’affecter au pixel de référence un poids plus élevé, comparativement aux pixels affectés au pixels qui l’entourent.
Tous les modes de réalisations illustrés sur les figures, pour lesquels on a n=3 ou n=9, peuvent être généralisés à un nombre n quelconque supérieur à 3. Le nombre n est toutefois de préférence impair, ce qui se prête avantageusement à la mise en oeuvre d’un filtre de pixels centré sur un pixel de référence, ce filtre tenant compte du pixel de référence. Très préférentiellement, n est un carré impair (ce qui permet la mise en oeuvre d’un filtre sur un voisinage de pixels de forme carrée autour d’un pixel de référence, ce filtre tenant compte du pixel de référence). On peut notamment noter les cas n=3, n=9, n=25 comme exemples de carrés impairs, qui peuvent s’appliquer à tous les modes de réalisations décrits précédemment.
Il a été constaté que chacun des modules de traitements 1 , 2, 3 respectivement représentés sur les figures 1 , 2 et 3 sont adaptés pour mettre en oeuvre le procédé de traitement d’un jeu de n données d’entrée exposé au début de la présente description détaillée, comprenant les étapes a) à d). Ces différents modules de traitement 1 , 2, 3 se présentent typiquement sous la forme de circuits électroniques (FPGA, ASIC ou autre) ; les différents blocs représentés sur ces figures sont ainsi des composants physiques inclus dans ces circuits électroniques. A des niveaux différents, ces modules de traitement occupent une surface très limitée car ne font pas d’opération complexe telle qu’un tri.
Ce qui précède vaut également pour les dispositifs de filtrage et les dispositifs de traitement d’image discutés précédemment.
Il est toutefois envisageable que le même procédé de traitement de n données d’entrée soit implémenté de manière logicielle, par un ordinateur non spécialisé. Les étapes du procédé sont ainsi codées sous la forme d’un programme d’ordinateur mis en oeuvre par un ou plusieurs processeurs. Il en va de même plus généralement pour le procédé de filtrage mis en oeuvre par l’un des dispositifs de filtrage illustrés sur les figures 4 et 5, voire pour le procédé de traitement d’image mis en oeuvre par le dispositif de traitement d’image 10 représenté sur la figure 6.
Dans les modes de réalisation décrits sur les figures, des modules de traitement 1 , 2, 3 sont utilisés en parallèle, ce qui permet de réduire la durée moyenne de détermination d’un fractile recherché. En variante, il peut être envisagé de répéter séquentiellement le procédé de traitement mis en oeuvre par un module de traitement 1 , 2 ou 3, plutôt que de le paralléliser, jusqu’à trouver un fractile qui correspond à ce que l’on cherche. Cette répétition est notamment facile à mettre en oeuvre lorsque le procédé est implémenté de manière logicielle ; il est dans ce cas possible de n’utiliser qu’un seul processeur pour cette mise en oeuvre séquentielle. Cette variante est en moyenne plus lente que la variante parallélisée, mais a pour avantage de consommer moins de charge de calcul à un instant t.
Une implémentation séquentielle est en outre particulièrement avantageuse lorsque l’on recherche non pas un fractile unique, mais plus généralement un fractile appartenant à un sous-ensemble de fractiles continu. En effet, l’exécution du procédé restera rapide, car un test d’appartenance à un sous-ensemble est plus facile à vérifier qu’une recherche de fractile unique. On peut par exemple se contenter d’un fractile proche de la médiane, dans la mesure où la durée prise pour l’obtenir est plus rapide que la durée qu’il faudrait consacrer à la détermination précise de la médiane.

Claims

REVENDICATIONS
1. Module de traitement (1 , 2, 3) d’un jeu de n données d’entrée comprenant une donnée de référence, chaque donnée d’entrée ayant une valeur, chaque donnée d’entrée étant par ailleurs associée à un poids, le module de traitement (1 , 2, 3) étant configuré pour : a) calculer la somme des poids associés seulement aux données d’entrée autres que la donnée de référence qui ont des valeurs strictement inférieures à la valeur de la donnée de référence, b) comparer la somme calculée à l’étape a) avec un premier seuil (Sa), c) calculer la somme des poids associés seulement aux données d’entrée autres que la donnée de référence qui ont des valeurs strictement supérieures à la valeur de la donnée de référence, d) comparer la somme calculée à l’étape c) avec un deuxième seuil (Sb), e) générer une donnée de sortie indiquant si la donnée de référence est un fractile du jeu inclus dans un sous-ensemble prédéterminé de fractiles, seulement si les deux conditions suivantes sont satisfaites : la somme calculée à l’étape a) est inférieure, strictement ou non, au premier seuil (Sa) et la somme calculée à l’étape c) est inférieure, strictement ou non, au deuxième seuil (Sb).
2. Module de traitement (1 , 2, 3) selon la revendication précédente, comprenant :
- une pluralité de premiers comparateurs agencés en parallèle, chaque premier comparateur étant configuré pour générer un résultat de comparaison entre la valeur de la donnée de référence et la valeur d’une autre donnée d’entrée du jeu,
- un premier additionneur configuré pour mettre en oeuvre l’étape a) sur la base des résultats générés par les premiers comparateurs.
3. Module de traitement (1 , 2, 3) selon l’une des revendications précédentes, comprenant :
- une pluralité de deuxièmes comparateurs agencés en parallèle, chaque deuxième comparateur étant configuré pour générer un résultat de comparaison entre la valeur de la donnée de référence et la valeur d’une autre donnée d’entrée du jeu,
- un deuxième additionneur configuré pour mettre en oeuvre l’étape c) sur la base de résultats générés par les deuxièmes comparateurs.
4. Module de traitement (1 , 2, 3) selon l’une des revendications précédentes, comprenant deux comparateurs configurés pour générer respectivement deux résultats de comparaison entre la valeur de la donnée de référence et la valeur d’une autre donnée d’entrée du jeu, dans lequel l’un des deux comparateurs est configuré pour se borner à tester une égalité entre la valeur de la donnée de référence et la valeur de l’autre donnée d’entrée du jeu, et l’autre des deux comparateurs est configuré pour se borner à tester une relation d’ordre entre la valeur de la donnée de référence et la valeur de l’autre donnée d’entrée du jeu, le module de traitement (1 , 2, 3) étant par ailleurs configuré pour croiser les deux résultats pour déterminer si le poids de l’autre valeur est à inclure dans la somme calculée à l’étape a) ou dans la somme calculée à l’étape c).
5. Module de traitement (1 , 2, 3) selon l’une des revendications précédentes, dans lequel la somme du premier seuil (Sa) et du deuxième seuil (Sb) est égale à s+p, où s est la somme des poids des n données d’entrée, et où p £ [-1 , 1], p étant fonction de savoir si la somme calculée à l’étape a) doit être inférieure au premier seuil de manière stricte et si la somme calculée à l’étape b) doit être inférieure au deuxième seuil de manière stricte pour que les deux conditions soient satisfaites.
6. Module de traitement (1 , 2, 3) selon l’une des revendications précédentes, l’ensemble de fractiles prédéterminé est constitué d’un unique fractile.
7. Module de traitement (1, 2, 3) selon l’une des revendications précédentes, dans lequel l’ensemble de fractiles prédéterminé comprend la médiane du jeu de n données d’entrée.
8. Module de traitement (1, 2, 3) selon l’une des revendications précédentes, dans lequel les n poids sont tous égaux à 1.
9. Module de traitement (1 , 2, 3) selon l’une des revendications précédentes, dans lequel le jeu de n données d’entrée est un voisinage de pixels dans une image.
10. Module de traitement (1 , 2, 3) selon l’une des revendications précédentes, dans lequel l’étape a) comprend : a1 ) initialiser un premier compteur à une somme ayant été calculée lors d’une précédente mise en oeuvre de l’étape a) par le module de traitement pour traiter un précédent jeu de données comprenant la même donnée de référence, le jeu de n données d’entrée comprenant par ailleurs au moins une nouvelle donnée qui n’était pas présente dans le précédent jeu de données, et le précédent jeu de données comprend au moins une ancienne donnée qui n’est pas présente dans le jeu de n données d’entrée, a2) pour chaque nouvelle donnée, incrémenter le premier compteur avec le poids associé à la nouvelle donnée, seulement si une relation prédéterminée entre la valeur de la nouvelle donnée et la valeur de la donnée de référence est vérifiée, a3) pour chaque ancienne donnée, décrémenter le premier compteur avec le poids associé à l’ancienne donnée, seulement si une relation prédéterminée entre la valeur de l’ancienne donnée et la valeur de la donnée de référence est vérifiée.
11. Module de traitement (1 , 2, 3) selon l’une des revendications précédentes, dans lequel l’étape c) comprend : c1 ) initialiser un deuxième compteur à une somme ayant été calculée lors d’une précédente mise en oeuvre de l’étape c) par le module de traitement pour traiter un précédent jeu de données comprenant la même donnée de référence, le jeu de n données d’entrée comprenant par ailleurs au moins une nouvelle donnée qui n’était pas présente dans le précédent jeu de données, et le précédent jeu de données comprend au moins une ancienne donnée qui n’est pas présente dans le jeu de n données d’entrée, c2) pour chaque nouvelle donnée, incrémenter le deuxième compteur avec le poids associé à la nouvelle donnée, seulement si une relation prédéterminée entre la valeur de la nouvelle donnée et la valeur de la donnée de référence est vérifiée, c3) pour chaque ancienne donnée, décrémenter le deuxième compteur avec le poids associé à l’ancienne donnée, seulement une relation prédéterminée entre la valeur de l’ancienne donnée et la valeur de la donnée de référence est vérifiée.
12. Module de traitement (1, 2, 3) selon l’une des revendications 10 et 11 , dans lequel les relations prédéterminées sont des relations d’ordre strict.
13. Module de traitement (1 , 2, 3) selon l’une des revendications 10 à 12, dans lequel le jeu de n données d’entrée et le précédent jeu de données sont des voisinages de pixels dans une image qui se chevauchent.
14. Module de traitement selon l’une des revendications précédentes, par ailleurs configuré pour :
- b') comparer la somme calculée à l’étape a) avec un troisième seuil (Sa’),
- d’) comparer la somme calculée à l’étape c) avec un quatrième seuil (Sb’),
- e’) générer une donnée de sortie indiquant si la donnée de référence est un fractile du jeu inclus dans un deuxième sous-ensemble prédéterminé de fractiles différent du sous- ensemble de l’étape e), seulement si les deux conditions suivantes sont satisfaites : la somme calculée à l’étape a) est inférieure, strictement ou non, au troisième seuil (Sa’) et la somme calculée à l’étape c) est inférieure, strictement ou non, au quatrième seuil (Sb’).
15. Dispositif de filtrage (4, 5, 8) d’un jeu de n données d’entrée de sorte à produire un fractile du jeu inclus dans un sous-ensemble prédéterminé de fractiles, chaque donnée d’entrée ayant une valeur, chaque donnée d’entrée étant par ailleurs associée à un poids, le dispositif de filtrage comprenant :
- une pluralité de modules de traitement (1 , 2, 3) selon l’une des revendications précédentes agencés en parallèle, chaque module de traitement (1 , 2, 3) étant associé en propre à une des n données d’entrée et configuré pour traiter comme donnée de référence la donnée d’entrée du jeu qui lui est associée en propre,
- un module de génération de fractile (6) configuré pour générer le fractile sur la base des données de sortie respectivement générées par les modules de traitement.
16. Dispositif de filtrage (4, 5, 8) selon la revendication précédente, dans lequel le module de génération de fractile (6) est configuré pour : f) pour chaque donnée de sortie générée par un module de traitement (1 , 2, 3), appliquer une opération de type et logique bit à bit entre la donnée de sortie générée par ce module de traitement et la valeur de la donnée d’entrée associée en propre au module de traitement, de sortir à produire des résultats, g) appliquer une opération de type ou logique bit à bit aux résultats de l’étape f).
17. Dispositif de filtrage (4, 5, 8) selon l’une des revendications 15 et 16, comprenant un comparateur configuré pour générer un résultat de comparaison entre la valeur d’une première donnée du jeu et la valeur d’une deuxième donnée du jeu, et dans lequel la pluralité de modules de traitement comprend :
- un premier module de traitement configuré pour traiter comme donnée de référence une première donnée du jeu, le premier module de traitement étant configuré pour mettre en oeuvre l’une parmi les étapes a) et c) sur la base du résultat généré par le comparateur,
- un deuxième module de traitement configuré pour traiter comme donnée de référence la deuxième donnée du jeu, le deuxième module de traitement étant configuré pour mettre en oeuvre l’autre parmi les étapes a) et c) sur la base du résultat généré par le même comparateur.
18. Dispositif de filtrage (4, 5, 8) selon l’une des revendications 15 à 17, dans lequel le jeu de n données d’entrées comprend deux données d’entrée communes avec un précédent jeu de données préalablement traité par le dispositif de filtrage (4, 8), et dans lequel un des modules de traitement est configuré pour mettre en oeuvre l’étape a) ou l’étape c) sur la base d’un résultat de comparaison entre les deux données d’entrée communes ayant été préalablement généré par le module de traitement pour traiter le précédent jeu de donnée.
19. Dispositif de filtrage (4, 5, 8) selon l’une des revendications 15 à 18, dans lequel l’étape a) mise en oeuvre par un module de traitement comprend : a1 ) initialiser un premier compteur à une somme ayant été calculée lors d’une précédente mise en oeuvre de l’étape a) pour filtrer un précédent jeu de données, le jeu de n données d’entrée comprenant au moins une nouvelle donnée qui n’était pas présente dans le précédent jeu de données, et comprenant une donnée d’entrée commune avec le précédent jeu de données, le précédent jeu de données comprenant au moins une ancienne donnée qui n’est pas présente dans le jeu de n données d’entrée, a2) pour chaque nouvelle donnée, incrémenter le premier compteur avec le poids associé à la nouvelle donnée, seulement si une relation prédéterminée entre la valeur de la nouvelle donnée et la valeur de la donnée d’entrée commune est vérifiée, a3) pour chaque ancienne donnée, décrémenter le premier compteur avec le poids associé à l’ancienne donnée, seulement si une relation prédéterminée entre la valeur de l’ancienne donnée et la valeur de la donnée d’entrée commune est vérifiée.
20. Dispositif de filtrage (4, 5, 8) selon l’une des revendications 15 à 19, dans lequel l’étape c) mise en oeuvre par un module de traitement comprend : c1 ) initialiser un premier compteur à une somme ayant été calculée lors d’une précédente mise en oeuvre de l’étape c) pour filtrer un précédent jeu de données, le jeu de n données d’entrée comprenant au moins une nouvelle donnée qui n’était pas présente dans le précédent jeu de données, et comprenant une donnée d’entrée commune avec le précédent jeu de données, le précédent jeu de données comprenant au moins une ancienne donnée qui n’est pas présente dans le jeu de n données d’entrée, cl) pour chaque nouvelle donnée, incrémenter le premier compteur avec le poids associé à la nouvelle donnée, seulement si une relation prédéterminée entre la valeur de la nouvelle donnée et la valeur de la donnée d’entrée commune est vérifiée, c3) pour chaque ancienne donnée, décrémenter le premier compteur avec le poids associé à l’ancienne donnée, seulement si une relation prédéterminée entre la valeur de l’ancienne donnée et la valeur de la donnée d’entrée commune est vérifiée.
21. Dispositif de filtrage (4, 5, 8) selon l’une des revendications 19 et 20, dans lequel les relations prédéterminées sont des relations d’ordre strict.
22. Dispositif de filtrage (5) selon l’une des revendications 15 à 21 , dans lequel le nombre de modules de traitement agencés en parallèle est strictement inférieur à n, de telle sorte qu’au moins une des n données d’entrée, dite donnée restante, n’est pas traitée comme donnée de référence par un quelconque des modules de traitement, le dispositif de filtrage comprenant par ailleurs un module complémentaire (7) configuré pour générer une donnée de sortie indiquant si la donnée restante est un fractile du jeu inclus dans le sous-ensemble prédéterminé de fractiles, sur la base des données de sortie générées par les modules de traitements.
23. Dispositif de traitement (10) d’une image d’entrée (A) pour produire une image de sortie (B), le dispositif de traitement (10) comprenant :
- un module de sélection de pixels (12) configuré pour sélectionner un voisinage de n pixels dans l’image d’entrée (A),
- un dispositif de filtrage (4, 8) selon l’une des revendications 15 à 22 configuré pour filtrer le voisinage de n pixels sélectionné, de sorte à produire un fractile du voisinage de n pixels, le fractile constituant une valeur d’un pixel de l’image de sortie (B).
24. Procédé de traitement d’un jeu de n données d’entrée comprenant une donnée de référence, chaque donnée d’entrée ayant une valeur, chaque donnée d’entrée étant par ailleurs associée à un poids, le procédé comprenant les étapes suivantes mises en oeuvre par un module de traitement (1 , 2, 3) : a) calculer la somme des poids associés seulement aux données d’entrée autres que la donnée de référence qui ont des valeurs strictement inférieures à la valeur de la donnée de référence, b) comparer la somme calculée à l’étape a) avec un premier seuil (Sa), c) calculer la somme des poids associés seulement aux données d’entrée autres que la donnée de référence qui ont des valeurs strictement supérieures à la valeur de la donnée de référence, d) comparer la somme calculée à l’étape c) avec un deuxième seuil (Sb), e) générer une donnée de sortie indiquant si la donnée de référence est un fractile du jeu inclus dans un sous-ensemble prédéterminé de fractiles, seulement si les deux conditions suivantes sont satisfaites : la somme calculée à l’étape a) est inférieure, strictement ou non, au premier seuil (Sa) et la somme calculée à l’étape c) est inférieure, strictement ou non, au deuxième seuil (Sb).
25. Procédé de filtrage d’un jeu de n données d’entrée de sorte à produire un fractile du jeu inclue dans un sous-ensemble prédéterminé de fractiles, chaque donnée d’entrée ayant une valeur, chaque donnée d’entrée étant par ailleurs associée à un poids, le procédé comprenant :
- mettre en oeuvre le procédé de traitement selon la revendication précédente plusieurs fois en parallèle, chaque mise en oeuvre dudit procédé de traitement traitant une donnée d’entrée différente du jeu comme donnée de référence,
- générer le fractile sur la base des données de sortie générées lors des mises en oeuvre parallèles du procédé de traitement.
26. Procédé selon l’une des revendications 24 et 25, dans lequel le jeu de n données d’entrée est un voisinage de pixels d’une image.
27. Produit programme d'ordinateur comprenant des instructions de code de programme pour l'exécution des étapes du procédé selon l’une des revendications 24 à 26, lorsque ce programme est exécuté par un ordinateur.
EP20797816.4A 2019-10-08 2020-10-08 Module de traitement de données identifiant un fractile d'un jeu de données Pending EP4042299A1 (fr)

Applications Claiming Priority (2)

Application Number Priority Date Filing Date Title
FR1911121A FR3101719A1 (fr) 2019-10-08 2019-10-08 Module de traitement de donnees identifiant un fractile d'un jeu de donnees
PCT/FR2020/051781 WO2021069845A1 (fr) 2019-10-08 2020-10-08 Module de traitement de données identifiant un fractile d'un jeu de données

Publications (1)

Publication Number Publication Date
EP4042299A1 true EP4042299A1 (fr) 2022-08-17

Family

ID=70228081

Family Applications (1)

Application Number Title Priority Date Filing Date
EP20797816.4A Pending EP4042299A1 (fr) 2019-10-08 2020-10-08 Module de traitement de données identifiant un fractile d'un jeu de données

Country Status (5)

Country Link
US (1) US20220374501A1 (fr)
EP (1) EP4042299A1 (fr)
CN (1) CN114651250B (fr)
FR (1) FR3101719A1 (fr)
WO (1) WO2021069845A1 (fr)

Families Citing this family (1)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
CN117674778A (zh) * 2023-11-16 2024-03-08 大湾区大学(筹) 一种五输入中值比较器、加速器单元和芯片

Family Cites Families (4)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
KR101704439B1 (ko) 2010-09-28 2017-02-09 삼성전자주식회사 메디안 필터링 방법 및 장치
GB2496201A (en) * 2011-11-07 2013-05-08 Sony Corp Context adaptive data encoding and decoding
DE102014208210A1 (de) * 2014-04-30 2015-11-19 Siemens Aktiengesellschaft Ableiten eines gerätespezifischen Wertes
GB2558271B (en) * 2016-12-23 2021-09-08 Imagination Tech Ltd Median determination

Also Published As

Publication number Publication date
CN114651250B (zh) 2024-11-26
US20220374501A1 (en) 2022-11-24
CN114651250A (zh) 2022-06-21
WO2021069845A1 (fr) 2021-04-15
FR3101719A1 (fr) 2021-04-09

Similar Documents

Publication Publication Date Title
EP2795831B1 (fr) Identification biometrique utilisant des filtres et par calcul multi partiesecurise
EP3043511B1 (fr) Procédé d&#39;identification d&#39;une entité
CN111507909A (zh) 一种有雾图像清晰化的方法、装置及存储介质
CN113989313A (zh) 基于图像多维分析的边缘检测方法及系统
EP3394797A1 (fr) Circuit neuronal optimise, architecture et procede pour l&#39;execution des reseaux de neurones
CN113538263A (zh) 基于改进DeblurGAN模型的去运动模糊方法、介质及设备
FR3087033A1 (fr) Procedes d&#39;apprentissage de parametres d&#39;un reseau de neurones a convolution et de detection d&#39;elements d&#39;interet visibles dans une image
EP0692762A1 (fr) Circuit logique de multiplication parallèle
CN114255190A (zh) 一种高光谱图像去模糊方法、系统及存储介质
WO2021069845A1 (fr) Module de traitement de données identifiant un fractile d&#39;un jeu de données
CN110110474B (zh) 一种基于金相图片的材料微结构几何模型建立方法
CN111383191A (zh) 用于血管断裂修复的图像处理方法及装置
EP3663989B1 (fr) Procédé et dispositif pour réduire la charge de calcul d&#39;un microprocesseur destiné à traiter des données par un réseau de neurones à convolution
CN117557562B (zh) 基于双流网络的图像篡改检测方法及系统
EP3511870B1 (fr) Procédés d&#39;apprentissage de paramètres d&#39;un réseau de neurones à convolution, et de classification d&#39;une donnée d&#39;entrée
WO2016050595A1 (fr) Procede de codage d&#39;un signal reel en un signal quantifie
Ooi et al. Enhanced dense space attention network for super-resolution construction from single input image
FR3156963A1 (fr) Méthode de super-résolution d’image présentant une robustesse universelle
WO2023118768A1 (fr) Dispositif et procédé de traitement de données d&#39;images de visages d&#39;êtres humains
EP4150574B1 (fr) Procédé de traitement d&#39;images
FR3127602A1 (fr) procédé de génération d’une image augmentée et dispositif associé
EP3314574A1 (fr) Procédé de segmentation d&#39;image
Katarya et al. Evolution of modern deep image inpainting methods
FR3159250A1 (fr) Circuit électronique de type multiplieur-accumulateur (MAC)
CN120430951A (zh) 一种多聚焦图像融合方法、装置、设备及存储介质

Legal Events

Date Code Title Description
STAA Information on the status of an ep patent application or granted ep patent

Free format text: STATUS: UNKNOWN

STAA Information on the status of an ep patent application or granted ep patent

Free format text: STATUS: THE INTERNATIONAL PUBLICATION HAS BEEN MADE

PUAI Public reference made under article 153(3) epc to a published international application that has entered the european phase

Free format text: ORIGINAL CODE: 0009012

STAA Information on the status of an ep patent application or granted ep patent

Free format text: STATUS: REQUEST FOR EXAMINATION WAS MADE

17P Request for examination filed

Effective date: 20220503

AK Designated contracting states

Kind code of ref document: A1

Designated state(s): AL AT BE BG CH CY CZ DE DK EE ES FI FR GB GR HR HU IE IS IT LI LT LU LV MC MK MT NL NO PL PT RO RS SE SI SK SM TR

DAV Request for validation of the european patent (deleted)
DAX Request for extension of the european patent (deleted)
STAA Information on the status of an ep patent application or granted ep patent

Free format text: STATUS: EXAMINATION IS IN PROGRESS

17Q First examination report despatched

Effective date: 20260121