David Tschumperlé

Keywords: Image Processing, C++ Library, Template-based programming, Genericity, Straightforwardness, Script language

The CImg Library is a minimal, easy-to-use, and capable C++ image processing library aiming to help developers implementing new image processing algorithms, from scratch. The library is versatile enough to deal with a large number of image types (from 1D-signals to temporal sequences of 3D-hyperspectral volumes), with any type of pixel values. At the same time, it is extremely straightforward to learn and to use. It proposes indeed a minimal set of four classes, all defined in a single C++ header file CImg.h that has very few (and adjustable) dependencies to third-party libraries. This makes CImg a small and handy image processing library, portable everywhere (supports multiple OS, CPU-architectures and compilers) and comfortable to maintain. Moreover, we introduce G'MIC, a simple script-language wrapping the CImg functionalities, so that all features of the library become available for a broader audience (non C++-programmers) who can use it either from the shell or from an interactive GUI.

CONTEXT AND MOTIVATIONS

The image processing world is full of very different people (computer scientists, mathematicians, physicians, biologists, ...), with diverse scientific backgrounds, working on a wide range of various image-related problems. This diversity, in terms of people, programming knowledges and data types is something one must take care of, when designing computer tools to assist those people in their goals : They don't all work on 2d gray-valued images only, and most of them do not have 15 years of experience in programming languages ! As a consequence, designing something as basic and important as an image processing library, should follow some minimal rules ensuring the simplicity, the genericity, the usefulness, the extensibility, the portability and the freedom of use of the library. This is what we have tried to achieve with CImg, a C++ library we started implementing in late 1999, designed primarily for researchers and students in image processing and computer vision. CImg is hosted on Sourceforge since 2003, at http://cimg.sourceforge.net and attracts each day a lot of people around the world (about 1200 visits and 100 downloads/day). In the followings, we detail the design choices we made to comply with the different rules mentioned above.

FEATURES

+

The CImg Library is a small library, distributed as a .zip package (≈ 12Mo) containing the library code (≈ 40k loc), examples of use, the reference documentation and resource files. The library itself is composed of a single C++ header file CImg.h which must be included in the user's code to be functional. All CImg classes and methods are encompassed in the namespace cimg library : #include "CImg.h" // Just do that... using namespace cimg_library; // Ready to go ! It is obvious then that the CImg library code is compiled at the same time as the user's code. As we will see later, this has a lot of advantages in terms of flexibility. This minimal set of classes already covers most of the image types we can encounter in real world application (from 1D scalar signals to collections of 3D hyperspectral images, with any type T of pixel values). The only template parameter T makes the understanding of the library affordable, even for non C++ experts.

CImg is a general image processing library that contains most of the usual image processing operators we would like to see in such a library. It is not specialized in a particular sub-field of image processing (e.g. mathematical morphology, variational calculus, spatial/spectral transforms, ...), but contains a lot of different functions to help writing complex algorithms with very few C++ code :

• Data inputs/outputs : CImg supports a large number of image file formats (e.g. JPEG, 16bits PNG, float-valued multipage TIFF, 3D Object File Format, PINK files, ...).

• Usual IP operators : Classical image processing operators are defined : filtering, mathematical morphology, histograms, color base conversions, interpolations, geometric transformations, non-linear blur/sharpening, displacement field estimation, FFT, and so on...

• Image drawing : Many methods allows to draw things in images : lines, polygons, ellipses, texts, vector fields, function graphs, 3d objects (Fig. 1a). • 3d object viewer : CImg owns a 3d object viewer (kind of mini-openGL), as well as many functions to generate 3d vector objects from dense image data (3d isolines, 3d isosurfaces, 3d elevations, 3d streamlines, ...). It does not rely on an external library for the 3d rendering. It supports light sources, texture mapping and transparent objects (Fig. 1b). • Arithmetic operators : Most usual mathematical operations between images are defined (e.g. operator+(), sqrt(), cos(), atan(), operator>>(),...). • Expression evaluator : CImg owns a numerical evaluator of mathematical expressions, allowing to quickly generate synthetic images from mathematical formula (whose formula can be chosen during the code execution) (Fig. 1c shows an example of a synthetic image, generated from the evaluation of "X=x-w/2;Y=y-h/2;D=sqrt(Xˆ2+Yˆ2); if(D+u * 20<80,abs(255 * cos(D/(5+c))), 10 * (y%(20+c)))"). Most of the image processing algorithms inside the library are defined as methods of the CImg classes (mostly for CImg<T> and CImgList<T>). In CImg, we decided not to separate the classes from the algorithms, as it is sometimes done in other template-based libraries (e.g. the STL). The separation between classes and algorithms is a nice concept when the data structures we want to work with are quite basic (e.g. 1-dimensional as vectors, lists, sets,...), as it makes sense that one generic algorithm can be applied to such many different structures (e.g. values sorting, re-ordering, searching for a value location). In the case of image processing, most of the algorithms we are interested in stay bounded to multidimensional image structures (who really wants to compute the FFT of a STL's std::multimap ?). Designing these algorithms in a too much generic way would be still possible, but would lead to a level of complexity that becomes discouraging for most average C++-programmers : it just means they will have to deal with a lot of template parameters as well as lots of weird iterators ! On the contrary, making the algorithms and the classes dependent as CImg does, allows to :

• Write algorithms that are optimized specifically for the CImg structures, e.g. by knowing in advance the pixel values ordering in the image data buffers, without needs for very specific iterators.

• Make the library more simple to use and to learn, by limiting the amount of genericity only to the classes (not to the algorithms). • Make the library classes depending on a minimal set of required template types (only one !).

Beside this simplicity, this approach also allows CImg algorithms to be pipelined in a way that writing image processing algorithms can be done usually in very few lines. This pipeline capability is illustrated with the following (extreme) example :

#include "CImg.h" using namespace cimg_library; int main() { CImg<> img("lena.bmp"); // Load color image.

// Do some weird operations. img.RGBtoYCBCr().channel(0).quantize(10,false).

map(CImg<>(3,1,1,3).rand(0,255). resize(10,1,1,3,3)); } The C++ code above loads an image, computes its luminance channel, quantizes it in 10 levels, then maps a colormap on it, containing 3 random colors interpolated along 10 levels (see Fig. 1d). As the entire code of the CImg library is contained inside a single header file, the library code is not pre-compiled but compiled onthe-fly, i.e. when the library user compiles its own code. This has a lot of advantages in terms of configuration flexibility :

• The user decides what should be the configuration of the library environment, e.g. the dependencies of CImg to thirdparty libraries, at the compile time, independently for each of its project. CImg defines indeed a lot of configuration macros that tells about which third-party libraries have to be linked in the final code : cimg use png, cimg use jpeg, cimg use tiff, cimg use lapack, cimg use fftw3, .... Depending on these configuration flags, extra functionalities are enabled in the library, as for instance the native support of some image file formats (PNG, JPEG, TIFF, ...) in CImg load/save methods.

• CImg defines a plug-in mechanism allowing users to add their own methods to the CImg classes, without having to modify the library source file. This is how it works in practice :

#define cimg_plugin "foo.h" #include "CImg.h" using namespace cimg_library; int main() { CImg<> img("lena.bmp"); // Call to a new custom method // of CImg<T> defined in 'foo.h' : img.my_method(); } If my method is intended to compute the gradient norm of a CImg<T>, we can write the plug-in file foo.h simply as : .sqr()). sqrt().move_to( * this); return * this; } Several plug-ins are already available in the CImg package (NLmeans, Skeleton, VRML reader, CImg to Matlab conversion, ...). Note that this kind of plug-in mechanism is not feasible when using a classical library whose code is pre-compiled.

+

The CImg library code is small, does not depend on many external libraries (can be compiled only with dependencies to libc and libm), and is easy to maintain. As a consequence, it has been possible to make it very portable and robust to different compilers, OS, and CPU architectures. It is known to run flawlessly on all Unix flavors (incl. Android), Windows and Mac OS. The library package is distributed under the permissive open-source CeCILL-C license (LGPL-like). The structures defined in CImg are insanely simple to manage, and the integration and communication of CImg with other libraries is facilitated.

A SCRIPT LANGUAGE FOR IMAGE PROCESSING

G'MIC stands for GREYC's Magic Image Converter. This project is hosted on Sourceforge since 2008, at http://gmic.sourceforge.net. It aims to :

• Define a lightweight but powerful script language (the G'MIC language) dedicated to the design of image processing pipelines.

• Provide an interpreter of this language, distributed as a C++ library embeddable in third-party applications (libgmic).

• Propose 3 usable binary tools embedding this interpreter :

1. The command-line executable gmic to use the G'MIC framework from a shell. In this setting, G'MIC may be seen as a direct (and friendly) competitor of the ImageMagick or GraphicsMagick software suites.

2. The interactive and extensible plug-in gmic gimp to bring G'MIC capabilities to the image retouching software GIMP.

3. ZArt, a real-time Qt-based interface for webcam images manipulation with G'MIC.

Due to its openness, this project attracts a lot of people everyday (≈ 450 downloads/day, more than 600.000 since Aug. 2008). The need for G'MIC has come from several observations :

1. CImg requires (basic) C++ knowledges to be used properly.

Still, many people in the image processing field do not know C++ enough, but could be interested by some of the CImg functionalities anyway.

2. When we get new image data, we often want to perform the same basic operations on them, for instance visualization, gradient computation, noise reduction, frequency analysis, ... Sometimes, the operations we need to apply are very specific to the images we just got (e.g. masking the Fourier transform to eliminate some frequency noise).

3. It is certainly not optimal to be forced to create new C++ code specifically for these minor tasks. This requires code edition, compilation time, and most often the code we have just wrote will be used only once in our lifetime ! From these observations, we created G'MIC as a script language interfacing all the CImg methods, to be usable from the shell. No compilation steps are required anymore for manipulating generic images.

From a technical point of view, G'MIC is based on these simple properties :

• G'MIC manages one list of images in memory (one instance of a CImgList<T>). The pixel type T can be chosen to be {bool|char|uchar|short|ushort|int| uint|float|double }. • Each G'MIC instruction runs an image processing algorithm (calling then one CImg method) either on one or several images of the list, or control the program execution : -blur, -mirror, -rgb2hsv, -isosurface3d, -if, -endif, -repeat, -done, -return, .... • User-defined scripts can be saved as G'MIC script files, and be recognized by the G'MIC interpreter.

• One G'MIC script can be called from the command line, or from any external project (through the libgmic library, embedding the G'MIC interpreter).

G'MIC is a very pleasant tool to manipulate generic images from the command line. Here, we show some examples of use.

• Add a synthetic degradation to an image (Fig. 2) :

gmic lena.bmp -blur 3 -sharpen 1000 -noise 30 -+ "'cos(x/3) * 30'" Fig. 2. Create a synthetic image degradation with G'MIC.

• Extract 3d structures from a dense volumetric image (Fig. 3) : (hist,hist2).get_append('c'). display_graph("Histograms"); }

• Using the G'MIC capabilities from GIMP (Fig. 5).

CONCLUSION

We have defined complete and generic open-source frameworks for image processing, covering different scales of use : A low-level library for C++ proprammers allowing to do algorithm prototyping (CImg), a script-language for command line users allowing to easily create image processing pipelines (gmic), and graphical interfaces (through the plug-in gmic gimp and ZArt) to provide image processing tools for a more general audience. This has been our way to try to reach as many people as possible interested by image processing techniques. Keep the things simple, affordable and useful !

4.

  CImgException : Used by the CImg library to throw exceptions, when errors are encountered in the library methods (I/O errors, bad arguments, ...).

  a) Example of drawing capabilities of CImg. b) Example of 3d rendering with CImg. c) Using the expression evaluator to generate a synthetic 2d color image (1 loc). d) Result of the pipeline example.

Fig. 1 .

 1 Fig. 1. Usefulness : Illustrating some CImg functionnalities.

  CImg<T>& my_method() { const CImgList<T> g = get_gradient("xyz"); (g[0].sqr() + g[1].sqr() + g[2]

Fig. 3 .

 3 Fig. 3. Extract 3d structures from a volumetric image with G'MIC.• Display histograms of an image and its gamma correction (Fig.4) :gmic milla.bmp --f '255 * (i/255)ˆ1.7' -histogram 128,0,255 -append c -plot is the G'MIC equivalent code to : #include "CImg.h" using namespace cimg_library; int main(int argc,char ** argv) { const CImg<> img("milla.bmp"), hist = img.get_histogram(128,0,255), img2 = img.get_fill("255 * ((i/255)ˆ1.7)",true), hist2 = img2.get_histogram(128,0,255); (hist,hist2).get_append('c'). display_graph("Histograms"); }

Fig. 4 .

 4 Fig. 4. Display histogram of an image and its gamma correction.

Fig. 5 .

 5 Fig. 5. Example of G'MIC running inside the plug-in for GIMP.

  The header file CImg.h defines only four different classes, only two of them having one template parameter :

	3. CImgDisplay : Represents a display window, where im-
	ages or images lists can be displayed. Multiple windows can
	be opened, and user interactions are managed through the
	class methods.

1. CImg<T> : Represents an image, having 4 dimensions (width, height, depth and spectrum), each pixel value being of type T. The pixel data are stored in a simple linear buffer T * data; of size width * height * depth * spectrum. 2. CImgList<T> : Represents a list of images CImg<T>. It is useful to manage a sequence or a collection of images (that may have different sizes).


David Tschumperlé

TENSOR-DIRECTED SIMULATION OF STROKES FOR IMAGE STYLIZATION WITH HATCHING AND CONTOURS

Keywords: Non-Photorealistic Rendering, Image Stylization, Sketching, Tensor Geometry, Stroke Simulation, Streamlines

We describe a simple but capable algorithm to generate sketches from color images. The method is based on the drawing of dark strokes on a white background, directed by an image-dependent tensor-valued geometry. It is able to produce various sketching styles with different kind of hatching and contours. Combining these grayscale sketches with the colors of the input images allows to produce a wide variety of image stylization renderings.

INTRODUCTION

In the field of non-photorealistic imagery, stroke-based techniques are often used as primary steps to render painterly or sketchy versions of input color images [START_REF] Hertzmann | A survey of stroke-based rendering[END_REF]. Many methods have been proposed in the literature, mainly to transform images into paintings [START_REF] Hertzmann | Painterly rendering with curved brush strokes of multiple sizes[END_REF], sketches [START_REF] Durand | Decoupling strokes and high-level attributes for interactive traditional drawing[END_REF], stipple drawings [START_REF] Deussen | Floating points: A method for computing stipple drawings[END_REF], comics [START_REF] Decarlo | Stylization and abstraction of photographs[END_REF], or pen-and-ink illustrations [START_REF] Deussen | Computer-generated pen-andink illustration of trees[END_REF][START_REF] Salisbury | Scale-dependent reproduction of pen-and-ink illustrations[END_REF][START_REF] Winkenbach | Computer-generated penand-ink illustration[END_REF]. Similar ideas have been used as well, for the visualization of vector and tensor fields [START_REF] Cabral | Imaging vector fields using line integral convolution[END_REF][START_REF] Tschumperlé | Tensor field visualization with pde's and application to dt-mri fiber visualization[END_REF], or medical images [START_REF] Bruckner | Style transfer functions for illustrative volume rendering[END_REF]. The main differences between these algorithms lie both in the placement and in the shape of the drawn primitives. Here, we propose an original stroke-based rendering algorithm which has the particularity of being able to generate both stylized edges and hatches at the same time. This is feasible through the consideration of a 2 nd -order tensorvalued geometry for the strokes. Such tensors can indeed describe local image structures having both isotropic (flat regions, background) or anisotropic shapes (contours). Thus, we "throw" either straight segments or curved streamlines, randomly placed on the image, in a way that they remain consistent with this prescribed tensor geometry. This makes regular hatches appearing on homogeneous areas while stylizing edges on image contours. Besides, our all-in-one method is particularly simple to implement and runs quickly, while being able to generate various rendering styles due to the high variability of the proposed tensor model (Fig. 1). At the end, we show more stylization results obtained by simple combinations between the grayscale output of our sketching algorithm with the colors of the input image.

A FIRST NAIVE APPROACH

In order to simulate the artistic drawing of black strokes on a white background, we suggest to determine a finite set of segments (roughly) representing the significant structures of an input color image I : Ω → R n . Many of the contour informations in I may be found in the gradient field of its luminance channel Y : Ω → R (or a smoothed version of it, if I is noisy). Based on this first assumption, we could build a very naive but straightforward image sketching algorithm, by applying the following processing pipeline : ∇Y . The stroke length L ≥ 0 may be proportional to ∇Y (x,y) (local edge contrast). 5. Loop to step 3. until enough strokes have been drawn on S.

Yet, this rudimental approach succeeds already in rendering notable sketch-like images (Fig. 2). But, some usual characteristics of artistical sketches are still missing : First, the method draws only straight strokes, which limits the stylization variety of the contours. Second, it does not generate aligned strokes on homogeneous areas of the image (background), i.e. when choosing ǫ → 0 (Fig. 2a).. Indeed, the gradient orientation ∇I ∇I has no clear meaning there (a) (ǫ, σ) = (0, 0)

(b) (ǫ, σ) = (20, 0) (c) (ǫ, σ) = (20, 1)
Fig. 2. Results of the naive approach with different parameter sets.

(since ∇I ≈ 0), and the drawn segments are randomly crossing without any spatial coherence, as hatching would typically demand.

In the followings, we propose to improve this naive approach by introducing tensor fields to model the strokes geometry, instead of considering a vector-valued one (as the gradient ∇Y ). We show that this extension allows to render both stylized contours on high-gradient areas and spatially regular cross-hatches on flat regions. Besides, we propose to naturally handle the drawing of curved strokes (using streamlines) in order to add more stylization diversity.

TENSOR-VALUED GEOMETRY OF STROKES

Second-order tensors are symmetric and positive-definite matrices suitable to model geometric features of either anisotropic or isotropic natures. Fields of 2 × 2 tensors have been successfully used so far in the literature, to model the geometry of local image structures (structure tensors) [START_REF] Zenzo | A note on the gradient of a multi-image[END_REF][START_REF] Weickert | Coherence-enhancing diffusion filtering[END_REF], or to describe local behaviors of diffusion processes for image denoising (diffusion tensors) [START_REF] Weickert | Coherence-enhancing diffusion filtering[END_REF][START_REF] Tschumperlé | Anisotropic diffusion partial differential equations for multichannel image regularization: Framework and applications[END_REF]. For our purpose of image sketching, we assume similarly that the strokes we would like to draw may have either isotropic (cross-hatch) or anisotropic (contour) configurations, whether the stroke is located on an flat region or on an image edge. Within this context, using a tensor field to locally model this variety of stroke arrangements looks quite natural. Our two-step approach is close to those in [START_REF] Weickert | Coherence-enhancing diffusion filtering[END_REF][START_REF] Tschumperlé | Anisotropic diffusion partial differential equations for multichannel image regularization: Framework and applications[END_REF] for the definition of diffusion tensors for image regularization : We first estimate the smoothed structure tensor field Gα,σ : Ω → P(2) :

Gα,σ = n i=1 ∇Iiα ∇I T iα * Gσ where Iiα = Ii * Gα (1)
Ii stands for the i th channel of the n-valued image I. On each image point (x, y) ∈ Ω, the positive eigenvalues λ+, λof G α,σ(x,y) give local informations on the color variation of I. The measure λ+ + λcan thus be used to determine on which kind of geometrical structure we are located (edge, flat region, corner). The corresponding orthogonal eigenvectors θ+, θtell about the orientation of these local structures. Actually, Gα,σ can be fairly represented by a field of ellipses of radii λ +/-(x,y) and orientations θ +/-(x,y) (Fig. 3a). Computing the structure tensor (1) guarantees that all color variations are considered at the same time, contrary to the naive approach where the image geometry is guessed only from the luminance channel Y . Besides, the smoothness parameters (α, σ) allow the estimated image geometry to be more robust to local noise and/or to be estimated at any spatial scale.

Once this local color geometry Gα,σ has been estimated, we model the strokes geometry by another tensor field T : Ω → P(2), defined as :

∀(x, y) ∈ Ω, T = c+θ+θ T + + c-θ-θ T - with c+ = 1 (1+λ + +λ -) p 1 and c-= 1 (1+λ + +λ -) p 2 (2)
(where p1 ≥ p2 ≥ 0). This field T has the following properties :

• Where T (x,y) is anisotropic, it will be oriented mainly along θ-(p1 ≥ p2). Then, (x, y) is likely on an image contour (higher λ +/-) and all strokes thrown from there must follow the edge direction θ-.

• Where T (x,y) is isotropic, it has no major orientations. Then (x, y) lies on an almost-flat image area, and all strokes thrown from there must generate a spatially coherent cross-hatching arrangement.

• The in-between configurations (swelled tensors) are expressed in a continuous manner and must generate semi-contours/hatches. The eigenvalues c +/-of T (x,y) are related to the length of the stroke at (x, y), both for contours and hatches. Satisfyingly, two parameters p1, p2 for T suffice to achieve a wide variety of sketching styles, since they are able to globally set at the same time the preferred tensor profiles (isotropic everywhere with p1 ≈ p2, anisotropic everywhere with p1 ≫ p2 ≫ 0, or a continuous mix of the two), as well as their way of depending on the local image contrast λ+ + λ-.

One example of such a stroke tensor field T is illustrated on Fig. 3b, with (p1, p2) = (1.2, 0.5) and (α, σ) = (0.5, 1.2). Thereafter, we show how to draw a set of strokes that precisely coincides with this prescribed tensor-valued stroke geometry T.

THROWING TENSOR-DIRECTED STROKES

Whereas the vector-directed stroke drawing algorithm (section 2) always uses the same orientation ∇Y (x,y) ∇Y (x,y) to draw a segment at one point (x, y), we want tensor-directed strokes to be rendered as single-or multiple-oriented segments (contours or hatches), whether T (x,y) is anisotropic or not. For this purpose, we decompose the tensor field T through several vector fields wγ : Ω → R 2 , each of them representing the amount of T along the orientation γ ∈ [0, π] of the plane. As

T = 2 π π γ=0
wγw T γ dγ , with wγ = √ Taγ √ T stands for the usual matrix square root. Each wγw T γ is a field of purely anisotropic unit tensors, oriented along wγ. Then, we get :

• Where T (x,y) is fully anisotropic (c+ ≈ 0), w γ(x,y) is equal to

(θ-.aγ)c 1 2
-θ-(parallel to θ-). Then, on image edges, the strokes will be necessarily drawn along the edge directions, whatever γ is.

• Where T (x,y) is fully isotropic (c+ ≈ c-), w γ(x,y) = c-aγ stays parallel to aγ. Then, on a flat region, multiple-oriented strokes with different angles γ will be generated from the same point (x, y). It enables the rendering of various hatching styles, depending on the way γ is discretized (i.e by the 3 parameters γmin, γmax and δγ).

• An in-between tensor will attract more or less the plane orientations aγ into its eigenvectors θ +/-, in accordance with its anisotropy. Such tensors allow to generate a smooth transition of the strokes arrangements, from contours to hatches.

The splitting of the tensor field T using several vector fields intuitively suggests to extend the stroke rendering algorithm by drawing streamlines of wγ, instead of straight lines (as in section 2). A streamline of length L is an integral curve C : [-L 2 , L 2 ] → R 2 , implicitely defined by :

∂C (l) ∂l = w(C (l) ) , where C (0) = (x, y) (3)
Considering such curves as stroke primitives is interesting, since they are able to stick to the image contours, whatever their curvatures are. Consequently, it create less harsh stylizations of the edges.

Finally, our tensor-directed stroke simulation algorithm reads : 1. Compute the stroke tensor field T (2) of the input color image I.

COLORIZATION AND CONCLUSION

Once the grayscale image of strokes have been generated, we can compose it with the colors of the input image in order to render the final sketch. To generate our results, we used only simple image composition techniques (multiplications, overlay, hard light,...), also sometimes blurring and boosting colors of the stylization results a little bit to make them more cartoonish. Sketches in Fig. 5,6 have been obtained with a single pass of our stroke-based rendering method, while Fig. 7 exhibits two results where several passes of our algorithm (from the same color input image, but with different parameters) have been merged. Additional paper texture have been added in the background to finalize the sketch rendering.

The tensor-directed stroke simulation algorithm we proposed is quite flexible and generic, and succeeds in creating sketches where the most important structures of the input images are extracted and displayed, thanks to the use of local tensor-valued geometric models. Yet, the algorithm is simple enough to be implemented quickly, and can be potentially parallelized for real-time applications. It opens interesting perspectives in the field of automatic and real-time conversions from videos to cartoon movies.

Fig. 1 . 1 .

 11 Fig. 1. A tensor-directed stroke algorithm is proposed, for the rendering of stylized images from an input color photograph (top-left). It is capable of generating various drawing styles.

Fig. 3 .

 3 Fig. 3. Structure and stroke tensor fields inlaid on an input image.

π γ=0 aγa T γ dγ = π 2 I

 2 d , with aγ = (cos γ sin γ) T , we have T = 2

2 .

 2 Split it to several vector fields wγ = √ Taγ, for γ discretized in [γmin, γmax] with an angular step δγ. 3. Initialize a white background image S : Ω → R. It will contain the final grayscale rendering of the sketch. 4. Pick a random location (x, y) in Ω. 5. For each available wγ, draw a (partially opaque) black segment from (x, y) -L w γ(x,y) to (x, y) + L w γ(x,y) , or a streamline (3) of wγ starting from (x, y), with length ||Lw γ(x,y) ||. 6. Loop to step 4. until enough strokes have been drawn on S.

Fig. 4

 4 Fig.4 illustrates the results of this algorithm on a synthetic image (top-left), with streamlines as primitives. Note how many different hatching styles can be generated whereas the parameters γmin, γmax, δγ change, The stroke tensors T are displayed as colored ellipses in the background of the generated sketches.

Fig. 4 .

 4 Fig. 4. Tensor-directed simulation of strokes from a synthetic image (top-left) containing both isotropic (noise) and anisotropic (stripes) structures. Corresponding (γmin, γmax, δγ) are (90 o , 90 o , 0) (topright), (0 o , 90 o , 90 o ) (bott.-left) and (15 o , 165 o , 20 o ) (bott. right).

Fig. 5 .

 5 Fig. 5. Various image stylization renderings using our proposed tensor-directed stroke simulation method. Images courtesy of Lyle Kroll (Skull image), and Geoff Livingston (Eiffel tower image, licensed under CC-SA).

Fig. 6 .

 6 Fig. 6. Simulation of chronological sketching steps towards a final painting (last image is the only input to our proposed algorithm).

Fig. 7 .

 7 Fig. 7. Generation of drawings from photographs. Several instances of the proposed tensor-directed stroke simulation algorithm have been combined here via simple layer compositions. Images courtesy of Tom Keil (licensed under CC-SA-NC).


Maxime Daisy
email: maxime.daisy@ensicaen.fr

David Tschumperlé
email: david.tschumperle@ensicaen.fr

Olivier Lézoray
email: olivier.lezoray@ensicaen.fr

Spatial patch blending for artefact reduction in pattern-based inpainting techniques

Keywords: inpainting, pattern, patch, blending

inpainting, is a popular processing technique aiming at reconstructing missing regions in images, by iteratively duplicating blocks of known image data (patches) inside the area to fill in. This kind of method is particularly effective to process wide image areas, thanks to its ability to reconstruct textured data. Nevertheless, "pathological" geometric configurations often happen, leading to visible reconstruction artifacts on inpainted images, whathever the chosen pattern-based inpainting algorithm. In this paper we focus on these problematic cases and propose a generic spatial-blending technique that can be adapted to any type of patch-based inpainting methods in order to reduce theses problematic artefacts.

Context and current issues

Image inppainting is the technique that is used to reconstruct the missing parts in an image while keeping the geometrical consistency in the reconstructed portion as much as possible. A good review of inpainting methods can be found in [START_REF] Caselles | Examplar-based image inpainting and applications[END_REF] where two main kinds of techniques are described:

-"Geometry-based" methods, introduced by Masnou and Morel [START_REF] Masnou | Level lines based disocclusion[END_REF] in their seminal work on area disocclusion by level-line completion, solve the inpainting problem by applying partial derivative equations and finiding a function that minimizes an energy that expresses the inpainting problem. These methods allow to locally extend the geometry of the image structures at the boundaries of the inpainting domain. Nevertheless, no texture regeneration is possible with these techniques, and spatial inconsistencies appear between known parts and reconstructed ones, especially for real images. -"Pattern-oriented" methods, introduced by Efros and Leung [START_REF] Efros | Texture synthesis by non-parametric sampling[END_REF] in their work on texture extrapolation, are based on copy and paste of patches from known parts of the image into the area to be recovered. These algorithms generate a kind of patchwork of image pieces by iteratively choosing the most similar patches to those living on the boundaries of the inpainting domain. Results given by these methods are particularly interesting for wide and textured area reconstructed.

Some variations intend to mix these two approaches to either create hybrid methods [START_REF] Arias | A variational framework for exemplar-based image inpainting[END_REF][START_REF] Kawai | Image inpainting considering brightness change and spatial locality of textures and its evaluation[END_REF][START_REF] Sun | Image completion with structure propagation[END_REF], or to to average several patches [START_REF] Le Meur | Examplar-based inpainting based on local geometry[END_REF][START_REF] Türkan | Image prediction based on neighbor-embedding methods[END_REF] to compute the final patch to use for the reconstruction. In any case, there are always local configurations that do not satisfy the selected similarity criteria. Copying and pasting, or averaging such kind of patches produces some visual artifacts appearing as block effects or discontinuities in the image. These configurations are actually not so uncommon: an inpainting mask often covers regions where transitions in texture or luminosity should occur and there are no ways a single patch taken around can fit perfectly for the reconstruction.

In this paper we introduce an original approach based on spatial patch blending, to reduce these kinds of artifacts. The advantages of our proposed algorithm are twofold: First, it can be used to post-process any type of pattern-based inpainting result, and second, it is able to reconstruct patches that are smart combinations of those located in the known area of the image. Moreover, we propose a way to perform this patch blending only on locations where inpainting artifacts occur by automatically detecting the most visible artefact points. The simultaneous application of these two contributions (spatial patch blending and inpainting artifacts detection) is illustrated by several inpainting results where the visual artifacts are clearly reduced compared to a classical patch-based inpainting approach.

This paper is organized as follows. Second section exposes the principle of our patch blending technique for patch-based image inpainting post processing. Third section shows how artifacts are detected from patch-based image inpainting results. Last section concludes with some commented results.

A patch blending algorithm for inpainting

This section shows how our spatial patch blending algorithm works, along with the modifications that have to be performed for patch-based inpainting methods to provide the data used in our blending algorithm.

Let I : Γ → R 3 + be a color image of which the missing pixels are defined over a domain Ω ⊂ Γ (inpainting mask). Let ψ p denote a square-sized (N × N with N odd) image patch centered at p ∈ Γ . The ith color component of a patch ψ p will be denoted by ψ i p ∈ R N ×N . Most of the pattern-oriented inpainting algorithms are based on two steps:

1. the research, for each p ∈ Ω, of the "best" patch ψ q (with ψ q ⊂ Γ \ Ω), 2. the copy of the patch ψ q on ψ p ∩ Ω inside the image I to be reconstructed.

Based on this copy/paste principle, the content of Ω is filled in an iterative and globally concentric way (however, some points of interest can be processed in priority).

Our technique consists in modifying this kind of inpainting algorithm to be able to post-process the inpainting result with patch blending method in order to visually improve the quality of the recovered image I. This modification requires to save both the map U : Γ → Γ of the locations of the centers of the original patches, and the map S : Ω → R 2 of the offsets between the reconstructed points and the centers of the partially copied patches. The connected component labelization L of U defines the partition of the patches pieces in the known parts of the image that were stuck back in Ω. Using the following data sets : I, U , S and L, we are able to generate an image J : Γ → R 3 + of which the patches of I, used to fill Ω, spatially blend one to another. In practice, for each point p ∈ Ω, this blending is realized with a set Ψ p of patches {ψ p1 , . . . , ψ pn }, obtained from a neighborhood V(p) around p, and that contains p. This set is built from a full search of all the centers of the different patches that were copied in V(p). Then, the blending is computed for the pixel p by the spatial merging of all the patches contained in Ψ p as follows for each color component i:

J i (p) = ψq∈Ψp w(q, p) ψ i q (p -q) ε + ψq∈Ψp w(q, p) (1)
with ε ∈ R close to 0 used to prevent a potential division by zero. The quantity ψ i q (p-q) represents the pixel value at the coordinates ((N/2, N/2) T + (p -q)) in ψ i q . The gaussian weights w(q, p) = e -d(q,p) 2 σ 2

give more importance in the blending computation to the patches of Ψ p , that are the spatially closest to the point p. The variance σ is a parameter related to the amplitude of the spatial merging. The function d(p, q) defines the minimal spatial distance between the point p and the sub-domain of the patch that was used for the reconstruction of q. d(q, p) = min

q ′ ∈V(p) q ′ -p where L(q ′ ) = L(q) (2)
The usage of the distance d(p, q) allows to generate a spatial blending orthogonally oriented according to the boundaries of the patches in the neighborhood of p. Fig. 2 illustrates a synthetical situation where we want to apply this blending technique. In the latter figure, p is the point where the blending has to be computed, and {ψ 0 , . . . , ψ 3 } are the patches contained in Ψ p . The x and y component of the vectors of S are respectively represented by the red and green components in the first figure. The point c 0 is the center of the patch ψ 0 and one has S(p) = c 0 -p. In Fig. 2(b), the arrows represent the minimal distances from p to each neighbor patch. The weights w related to ψ 1 , ψ 2 , ψ 3 are respectively represented by the lighting intensities in the red, green and blue channels (with w(p, q) = 0 for q ∈ ψ 0 ). Algorithm. 1. summarizes the main steps of our patch blending process. Our spatial patch blending technique uses all the patches from which a point p ∈ Ω could have been reconstructed during the inpainting process if the filling order had been different from those really used. Intuitively this comes to keep a list of candidate patches (rather than the only one of the basic copy/paste process) for each p ∈ Ω reconstructed during a patch-based inpainting. It is very different from an inpainting process that would average the K best patches (like in [START_REF] Le Meur | Examplar-based inpainting based on local geometry[END_REF]) to reconstruct each point p since here the blending uses the geometry of the piece of patch copied at p and also the spatial configuration of the neighbour patches. One can notice that the blending is computed with a constant amplitude σ. Actually, all the areas of the inpainted image do not contain breaks of the same strength, so it would be naturally desirable to be able to locally vary σ. Hence, the third section explains our second contribution, the adaptation of σ to the local artifacts strength.

Automatic detection of inpainting artifacts

In this section, we explain a method to automatically detect artifacts produced by patchbased inpainting algorithms. This method uses additional data provided by modifying patch-based inpainting methods. Most of the visual artifacts due to a reconstruction mainly appear when two patches with not enough similarity were copied close to each other inside Ω. In practice, the point p ∈ Ω where artifacts appear are inside areas verifying these two conditions :

1. ∇I(p) is high, and so indicates strong spatial discontinuities in the image values. 2. Patches pasted inside the neighborhood of p come from different and far locations producing discontinuities inside U .

Therefore, our proposition is to track down the set E of these artifact points (also named break points) as the set of points verifying the condition R(p) > τ where :

∀p ∈ Ω, R(p) = ∇I(p) • | div(U )(p) | α (3)
and α = (max q∈I ∇I(q) )×(max q∈I |div(U (q))|) is a normalization factor allowing the user parameter τ , related to the detected break points density, to be chosen within

where w b (p, r) = e -p-r 2 (3ρR(r)) 2 and ρ is a user parameter defining the maximal width of the spatial patch blending inside J. Using σ = σ(p) in the patch blending equation [START_REF] Caselles | Examplar-based image inpainting and applications[END_REF], we are able to locally change the blending amplitude according to the presence (also the strength) or not of the artifacts. For the sake of performance, the blending is made only inside a subset Ω ′ ⊂ Γ where σ(p) is high enough. It should be noted that in the case of strongly textured areas, it may happen that 1. and 2. are simultaneously verified for some points where no visual artifact exist. The experiments we made suggest that using spatial patch blending in these areas does generally not damage the quality of the reconstruction. Fig. 4, 3 and 5 illustrate different results of blended inpainting on synthetic and real color images, as well as comparisons with other classical inpainting algorithms presented in [START_REF] Le Meur | Examplar-based inpainting based on local geometry[END_REF][START_REF] Tschumperlé | Vector-valued image regularization with pdes: A common framework for different applications[END_REF][START_REF] Criminisi | Region filling and object removal by exemplar-based image inpainting[END_REF][START_REF] Harrison | Image Texture Tools[END_REF][START_REF] Pérez | Patchworks: Example-based region tiling for image editing[END_REF]. The top row images of Fig. 3 were post-processed with the same contrast enhancement filter for printing quality purpose. Through these examples, it is particularly interesting to see that our proposed blending method creates results which have all the good properties of other approaches at the same time, something between pure diffusion techniques (Fig. 4b) where colors are smoothly interpolated but without reconstructed textures, and pure patch-based techniques (Fig. 4c) where repetitive patterns are fully reconstructed. This way, the visual artefacts due to incoherent patch collage are strongly reduced, while the computation time overhead is negligible. The effect is close to of the results in [START_REF] Arias | A variational framework for exemplar-based image inpainting[END_REF][START_REF] Pérez | Poisson image editing[END_REF], but takes less time to compute. Moreover, our approach only requires to set two additional parameters τ et ρ which are intuitive and easy to adjust. This makes our contribution very generic, and relevant for the improvement of any kind of patch-based inpainting algorithms.

Fig. 1 :

 1 Fig. 1: Illustration of our contribution : (a) masked image to be reconstructed, (b) zoom on inpainted result by classical copy-paste of patches, (c) zoom on inpainted result with our patch blending algorithm, proposed in this paper.

  (a) Representation of the map S of the offsets with the patch centers. (b) Representation of the weights w used to compute (1) for every point of ψ0.

Fig. 2 :

 2 Fig. 2: Illustration of both S and w quantities computed for the patch blending.

Algorithm 1 : 8 J

 18 Spatial patch blending for inpainting for p ∈ Ω do 1 var centers = list(∅); 2 var distances = list(∅); 3 for q ∈ V(p) do 4 var c = q + S(q) ; 5 if (c ∈ centers) ∧ (p ∈ ψc) then 6 insert(centers, c) ; 7 insert(distances, d(c, p)) ; // see (2) (p) = blend(p, centers, distances) ; // see (1)

  [0, 1]. R(p) is used to locally estimate the strength of the geometrical break due to the reconstruction since |div(U )| determines whether two patches stuck next to each other come from close locations (low |div(U )|), or far locations (high |div(U )|). Consequently, if R(p) is high, the point p fulfills both 1. and 2. and is more likely to locate an artifact inside the image I. By associating to each point p ∈ E a Gaussian function the variance of which depends on R(p), a spatial map σ : Γ → R + of the local blending amplitude can be defined as follows: ∀p ∈ Γ, σ(p) = ρ × r∈E w b (p, r) max q∈Γ r∈E w b (q, r)

  (a) Masked colored image. (b) Inpainting result from [12]. (c) Inpainting result + patch blending (proposed algorithm). (d) Masked colored image. (e) Inpainting obtained with the algorithm from [7].(f) Inpainting result + patch blending (proposed algorithm).

Fig. 3 :Fig. 4 :

 34 Fig. 3: Comparison with the resynthetizer algorithm [7,12].

  (a) Masked colored image (used in[START_REF] Le Meur | Examplar-based inpainting based on local geometry[END_REF]). (b) Inpainting result from [7]. (c) Inpainting result + patch blending (proposed algorithm). (d) Masked colored image. (e) Inpainting result in [10]. (f) Inpainting result + patch blending (proposed algorithm).(g) Masked image.(h) Inpainting obtained with[START_REF] Harrison | Image Texture Tools[END_REF].(i) Inpainting obtained with[START_REF] Criminisi | Region filling and object removal by exemplar-based image inpainting[END_REF].(j) Inpainting result + patch blending (proposed algorithm).

Fig. 5 :

 5 Fig. 5: Comparison of the patch blending results with the state of the art inpainting methods [7,10,11].


P Eudes

Z Basrak

F S Ébille

G Royer

Towards a unified description of fusion evaporation-residue cross sections above the barrier

Keywords: 25, 70, Jj -Fusion and fusion-fission reactions 25, 70, -z -Low and intermediate energy heavy-ion reactions

A meticulous study of nearly 300 fusion-evaporation cross section data reveals that, when properly scaled, fusion excitation function complies with a universal homographic law which is, within experimental errors, reaction system independent. From a such complete and summed complete and incomplete fusion excitation functions extracted are the limiting energy for the complete fusion and the main characteristics (onset, maximum and vanishing) of the incomplete fusion. The DYWAN microscopic transport model correctly predicts the incomplete fusion cross section for incident energies 15A MeV and suggests that the nuclear transparency is at the origin of fusion disappearance.

Introduction. -Since mid-seventies of the last century it is consensual that heavy-ion fusion reaction as a function of the center-of-mass energy passes through three distinct regions, that of rising (I), stagnating (II), and falling (III) cross sections, respectively. At low energies, the regions I and II have been systematically studied by confronting models with a myriad of experimental data [1][START_REF] Bass | Nuclear Reactions with Heavy Ions[END_REF][START_REF] Swiatecki | [END_REF][4][5][6][7][8][9][10]. In the region III, the incomplete fusion (IF) reaction mechanism opens and increasingly competes with the complete fusion (CF). To this region of fusion only two systematic analyses have been devoted by studying reactions leading to a rather light compound nucleus for which the formation of an evaporation residue is by far the main decay mode [11,12]. In the first study, Morgenstern et al. [11] have extracted the ratio of CF to CF + IF fusion cross sections showing that the energy of vanishing CF and that of the IF threshold strongly depend on the mass asymmetry of the system. In the second systematics, Lautesse et al. [12] have presented a fusion-evaporation excitation function relative to 7 light and quite symmetric systems including their own measurements around the Fermi energy of the Ar + Ni and Ni + Ni reactions. 1 Thereby, IF process vanishes at incident energy of about 50A MeV.

In line with previous studies, the goal of this letter is fourfold: 1 The reported single-source cross sections of these two reactions are in the ensemble of collected fusion data the only ones which include both evaporation and multi-fragment channel contributions.

(i) Establish the first exhaustive systematics of CF as well as of CF + IF fusion-evaporation cross sections in region III.

(ii) Assess the global characteristics of fusion excitation function and reveal to which extent one may render it independent of reaction system.

(iii) Extract the main characteristics of both CF and IF components of fusion.

(iv) Testify that the fusion excitation function can be an interesting observable to constrain microscopic transport codes.

Being focused on the region III of fusion we restrict our search of fusion data at incident energy higher than about 3A -4A MeV. From the published reports we collected 238 total fusion-evaporation cross sections belonging to 48 reaction systems and additional 60 CF data points belonging to 14 of the above systems with explicitely extracted both CF and IF cross sections. Data span over system mass A sys = A trg + A prj = 26 -164 nucleons (A trg (A prj ) denotes target (projectile) mass number), mass asymmetry α = |A trg -A prj |/(A trg +A prj ) = 0 -0.512, and neutronto-proton content N sys /Z sys = 1 -1.429. Despite a broad coverage in the α and N sys /Z sys variables many of data are for the mass symmetric systems and, in particular, for the systems with the equal number of neutrons N sys and protons Z sys . About 100 additional data points from those measurements which have reported existence of a non-negligible fusion-fission component will be presented

LABORATORY ENERGY (A.MeV) NORMALIZED CROSS SECTION

14N+12C [18,19] 20Ne+16O [20] 24Mg+12C [21] 12C+27Al [22] 16O+24Mg [23] 20Ne+20Ne [20] 28Si+12C [24,25] 14N+27Al [26] 16O+26Mg [23] 18O+24Mg [23] 16O+27Al [27][28][29] 32S+12C [30][31][32][33][34] 20Ne+26Mg [35] 20Ne+27Al [28,36] 20Ne+27Al [28,36] 35Cl+12C [37][38][39] 16O+32S [28] 16O+40Ca [40,41] 28Si+28Si [42][43][44][45][46] 28Si+28Si [42][43][44][45][46] 32S+24Mg [47,48] 19F+40Ca [49,50] 32S+27Al [28,49] 35Cl+24Mg [51,52] 12C+48Ti [22] 23Na+40Ca [50] 16O+48Ti [53] 14N+52Cr [26] 40Ar+27Al [54] 28Si+40Ca [50,55] 12C+58Ni [22] 14N+58Ni [26] 36Ar+36KCl [56] 12C+63Cu [22] 40Ar+40Ca [57][58][59][60] 40Ca+40Ca [61] 58Ni+27Al [62] 24Mg+63Cu [63] 48Ti+45Sc [64] 36Ar+58Ni [12] 16O+92Mo [65] 52Cr+56Fe [65] 19F+93Nb [66] 64Zn+48Ti [54] 58Ni+58Ni [12] 18O+100Mo [67] 12C+124Sn [68,69] 14N+124Sn [68] 20Ne+124Sn [68] 40Ar+124Sn [68] in a subsequent and more extensive work [13] but with thus enlarged data set our results and conclusions rest unaltered. The preliminary results of this work have been presented earlier [START_REF] Eudes | i nProceedings of the 11th International Conference on Nucleus-Nucleus Collisions,e d i t e d[END_REF].

Fusion excitation function. -In order to compare the fusion cross sections σ F belonging to so different reaction systems it is mandatory to account for the proportionality of σ F to the size of the system by renormalizing σ F by the (total) reaction cross section σ R at the same incident energy E inc = E lab /A prj . We extensively studied the reliability of results for four parameterizations of σ R [START_REF] Bass | Nuclear Reactions with Heavy Ions[END_REF][START_REF] Kox | [END_REF][16][17] and their influence on our investigation [13]. The two most recent of these empirical formulas give the most and about equally convincing predictions for σ R over the full domain of fusion data with respect to E inc , A sys , α,andN sys /Z sys . 4)) is shown as full red curve in both main panel and inset. The background band around the best fit curve is due to the errors on the fit parameters provided by the code used [70], see also in table 1. Small circles are drawn over those data points which were rejected by the fitting procedure. A lightgray band for E avail < 1.04 MeV/nucleon delimits the region III from fusion regions I + II. Inset shows by darkgray circles those data points which survived the rejection through the iterative fitting procedure.

We present here the results obtained with the Shen formula [16] while an almost identical result (within a few per mill) obtained when σ F is normalized by the σ R due to Tripathi [17] will be presented elsewhere [13]. 2Figure 1 displays normalized CF + IF fusion-evaporation cross sections σ N = σ F /σ R for the 48 systems studied as a function of E inc in the laboratory reference frame in the spirit of ref. [12]. Data are sorted by the increasing A sys and systems are differentiated by diverse symbols and a color code (online). The same symbol and color code is used for a given system throughout this letter. As expected, σ N decreases with increasing E inc .M o r e o v e r ,w i t h the normalization applied to fusion cross sections, most of the systems gather in a single arc-like zone: σ N from a maximum of ∼ 0.85 -0.95 σ R occurring at E inc ≈ 3A-4A MeV gradually decreases and extincts somewhere about 50A MeV but it extends up to 80A MeV for the highly mass asymmetric 12 C+ 124 Sn system [68].

In order to further gather the data points we express energy in units of the so-called (system) available energy, i.e. center-of-mass energy per nucleon

E avail = E c.m. A sys = E lab A prj A prj A trg (A prj + A trg ) 2 .
(

) 1
Table 1: Values of the best fit coefficients a, b,a n dc and their uncertainties ∆a,∆ b,a n d∆ c of a homographic function (eq. ( 4)) obtained with the MINUIT package of the CERN library [70]. The first row is for the 238 complete (CF) plus incomplete (IF) fusion evaporation-residue data and the second for the subset of 60 CF data from those experiments in which the contribution of CF and IF fusion components have been explicitly reported, respectively.

Data set a ± ∆ab ± ∆bc ± ∆c Sum of CF and IF fusion -0.0925 ± 0.0019 1.278 ± 0.029 0.629 ± 0.034 CF fusion component only -0.217 ± 0.025 1.43 ± 0.12 0.419 ± 0.098 Indeed, by scaling the abscissa in the units of the available energy one does express the mass asymmetric systems on the same footing with those which are mass symmetric. Such a coordinate scaling greatly ease the comparison of systems of the different asymmetry α. The obtained result is displayed in fig. 2. On that manner, as a function of E avail , irrespectively of the individual characteristics of a given reaction system, an overwhelming majority of data follow the same trend. Note, however, the data are very unevenly distributed along the arc. The density of points is much greater for E avail 3 MeV/nucleon with a kind of stack of the data for E avail < 1.5 MeV/nucleon. Quite on the contrary, for E avail > 5 MeV/nucleon fusion data are very scarce. A similar conclusion on the experimental coverage of fusion as a function of energy may be drawn from fig. 1.

Let us interpret the observation that σ N data as a function of energy gather along an arc. In a first approximation σ F and σ R may be expressed by a common functional form

σ(E)=πr 2 (1 - V E ), (2)
in which the cross section depends inversely on energy E while the effective radius r and the strength of interaction potential V may be considered constants for a given system (see e.g. refs. [START_REF] Bass | Nuclear Reactions with Heavy Ions[END_REF]16]). 3 In this approximation σ N reads

σ N (E c.m. )= a 1 + b 1 /E c.m. a 2 + b 2 /E c.m. , (3)
where a i and b i are constants. Eq. ( 3) is equivalent to a homographic function in energy and which we take to be our probe-function

f (x)=a + b c + x , (4)
with x = E avail and a, b,a n dc the fit parameters. We apply the above functional relation between normalized cross section and energy to collected experimental fusion data. We start with the full ensemble of σ N data and allow to the fit procedure to iteratively exclude from the next step of fitting those data points which are outside the best fit result by more than three times the corresponding experimental error bar 4 . The consequence of the iterative procedure is a slightly improved description of the mid-region of the arc with no change at its extrema. A stable result has been achieved in four iterations and it is displayed in fig. 2 Speaking of uncertainty in absolute cross sections it is instructive to examine the 28 Si+ 28 Si data (green diamonds). In five experiments 22 fusion cross section values are reported [42][43][44][45][46]. Some of them, taken at the same or very close E inc , differ substantially (see in fig. 1 b) ). These discrepancies give an insight into the limits of the precision in deducing the fusion cross section absolute values experimentally and may explain why about 25 % of the data points are removed by the fitting procedure. The group of 16 rejected data points with E avail 2.3 MeV/nucleon lying well above the general data trend and which were all measured in seventies of the last century is puzzling. A careful examination of these works could not identify an obvious error or inconsistency in data taking and analysis. Forty years ago, however, the knowledge on deep inelastic process has been far less complete. Without a coincidence measurement it is rather difficult to unambiguously separate fusion-like mechanisms from deep inelastic collisions that involve large transfer of momentum and which may significantly affect the σ F . The most likely, these 16 data suffer an incorrectly assigned σ F value, thus calling to remeasure them [13]. 5 The fit parameters are reported in table 1. From them one infers the value of the vanishing energy of incomplete fusion process at E avail = 13.2 ± 0.6 MeV/nucleon 6 . The uncertainty on the fit parameters is 4 Error on fusion cross section ∆σ F is generally in the range of 0.05 -0.15 σ F . In case of a non-reported experimental error it has been assumed to be 20 % of the corresponding σ F value. No error on σ R is considered. 5 Regarding the 14 N+ 12 C system, we remind the reader that in their study of the fusion excitation function for 54 individual fusion reactions in the σ F vs. 1/Ec.m. representation Giordano et al. [8] have achieved very satisfactory fit to all reactions over the whole available data set except for the portion of the 14 N+ 12 C [18,19] data with Ec.m./A > 1.8 MeV/nucleon (cf. in fig. 1 of ref. [8]), i.e. for the same points of this reaction which are rejected by the fitting procedure. 6 When data are normalized with σ R of ref. [17] the result is E avail =13.2± 0.7 MeV/nucleon. ⊗ BUU [71] Ar + Zr SMF [72] Ar + Ni Landau-Vlasov Fig. 3: (Color online.) Prediction of σN as a function of E avail by dynamical simulations. Full symbols are calculated with the DYWAN model (Zamick soft EOS and the isospin-and energy-dependent phenomenological σNN)f o rt h eA r+A r ,N i , and Ni + Ni reactions. When plotted, the error bars represent extrema over several independent simulations. Encircled diamonds stand for the Landau-Vlasov simulation of the Ar + Ni reaction (Gogny G1D1 EOS and the isospin-and energydependent phenomenological σNN). The BUU simulation results are presented by encircled: point (Ar+Al, soft EOS, σNN = 50 mb), plus sign (Ca+Ca, soft EOS, σNN = 41 mb), and cross (Ca+Ca, stiff EOS, σNN = 41 mb), respectively [71]. The result of the SMF-Langevin type simulation of the Ar + Zr system is shown by encircled star symbols [72]. Theoretical fusion cross sections are normalized on the same way as experimental ones. Curve is the fit function from fig. 2.

rather small (see the narrow orange band around the best fit curve in fig. 2) and consequently that on the energy of disappearance is not too large either. Theoretical predictions. -Theoretical works on fusion at energies of region III have mostly been devoted to a qualitative study of the phenomenon with little predictions on fusion cross section values. A rare example of the published quantitative studies of fusion excitation function by microscopic transport theories is a simulation of the Ar + Al and Ca + Ca reactions within the semiclassical BUU model [71]. These results are displayed by encircled point, plus sign, and cross symbols, respectively in fig. 3. Neither the shape nor its absolute value follow the common data trend reproduced by our universal homographic function. Our own unpublished calculation relying on the semiclassical Landau-Vlasov model [73] predicts fusion values comparably far from the universal behavior of the scaled fusion excitation function (see encircled diamonds in fig. 3). Fusion cross sections for the 36 Ar + 96 Zr system at 9A and 16A MeV have recently been investigated using the Langevin force in order to describe density fluctuations [72] (see encircled star symbols in fig. 3). At higher investigated energy the model predicts a value close to the experimental data while at 9A MeV the simulation underestimates our universal law. A study extended to other energies and systems would be necessary before a conclusion on the success of this approach.

It was, thus, a challenge to address this basically onebody problem by means of the DYWAN model, a microscopic approach describing the dynamics of heavy-ion collisions at intermediate energies [74]. The DYWAN model solves an extended TDHF equation by projecting single particle wave functions onto a wavelet basis. The resulting one-body density matrix is a superposition of the Slater determinants of wavelets. Simulation results of fusion cross section for the Ar + Ar,A r+N i ,a n dN i+N ir e a ctions are shown by filled symbols in fig 3. The scaled fusion excitation function is fairly well predicted for E avail 3.75 MeV/nucleon (for mass symmetric systems that means for E inc 15A MeV). The DYWAN model reproduces both dependence on energy for a given system as well as homographic universality of scaled excitation function. General fusion data is not well reproduced at lower energies. That is not surprising since at this range of energy the model attains its validity limits.

Figure 4 displays the DYWAN density projected onto the reaction plane at selected times of the Ni + Ni reaction. From fig. 4 one infers that at 60A MeV in central collisions reaction system promptly reseparates giving rise to a binary exit channel of the dynamically induced fission-like process. The laps of time between the contact and the maximal compression (panels a) and b) in fig. 4, respectively) is roughly a third of the time which system takes to split after reaching its the most compact stage (panels b) and d) in fig. 4). Consequently, the nuclear transparency, i.e. an insufficient stopping power seems to be at the origin of the vanishing of the fusion reaction mechanism. The fusion extinction may be interpreted in terms of a longer mean free path at the Fermi energy region due to the interplay between a weakened nuclear mean field and a p-4 still insufficient stopping efficiency of nucleon-nucleon collisions. This feature has been several times discussed in the past [75][76][77][START_REF] Novosel | [END_REF] and has recently received an experimental confirmation [79].

Complete and incomplete fusion excitation functions. -Only twelve experiments have explicitly been designed to measure both CF and IF fusion components. The resultant 60 CF σ N belonging to 14 systems are normalized on the same way as previously studied CF + IF excitation function and are plotted in fig. 5 as a function of E avail . The same fitting applied to these 60 points resulted in the best fit curve shown by the darkred full curve. In the fitting procedure 3 points were excluded only, all of them from those measurements the IF data of which were excluded be the fitting in fig. 2. These points are marked by lighter colors of the corresponding symbols. In the case of CF the best fit homographic function steeply decreases and the complete fusion reaction mechanism vanishes at E avail =6.2 +1.3 -1.1 MeV/nucleon. Unlikely to the best fit of CF + IF data the uncertainty on the CF fit coefficients is considerably larger (see table 1) which reflects itself in a larger uncertainty on the energy of CF disappearance.

Inset in fig. 5 shows σ N data vs. 1/E avail . This presentation is inspired by the usual way of showing (non-scaled) fusion excitation functions in the σ F vs. 1/E c.m. plane in which, owing to eq. ( 2), the three regions of fusion are represented by linear segments (see e.g. in refs. [START_REF] Bass | Nuclear Reactions with Heavy Ions[END_REF]36]). Our scaling brings the different systems to lie, on the average, on a common curve made of two segments of the homographic function and not of two straight lines. In the inset the fusion regions II and III are clearly distinct and the limit between them occurs at E avail ≈ 1.04 MeV/nucleon independently of the system studied. The fits are carried out on the same manner as before for each fusion region. In the inset, darkgreen dash-dotted and almost horizontal curve fits the region II, whereas the region III is fitted by the darkred full curve, i.e. the same as in the main panel in fig. 5. The existence of these two regions of fusion is emphasized in fig. 2 by the lightgray band for E avail < 1.04 MeV/nucleon.

It is established that the CF reaction mechanism ceases to exist owing to the dynamical pre-equilibrium emission [11] and CF is progressively replaced by IF. For CF, the center-of-mass energy and the excitation energy E * are up to reaction Q-value equivalent (see short-dashed darkred curve in fig. 5). One infers that an energy of 6 MeV/nucleon, i.e. a value considerably lower than the average nucleonic binding energy, can at most be deposited into a light compound nucleus produced via heavy-ion collision. Higher values are precluded owing to the dynamical release of excitation energy. It would be very interesting to investigate whether this limit changes for substantially heavier systems.

The established homographic law of the region III of fusion for both CF (full darkred curve in fig. 5) and CF + IF (red full (long-dashed) curve in fig. 2

AVAILABLE ENERGY (MeV/A) NORMALIZED CROSS SECTION

28Si+12C [29] 16O+27Al [34] 32S+12C [39] 20Ne+26Mg [40] 20Ne+27Al [41] 35Cl+12C [42] 16O+40Ca [46] 28Si+28Si [48] 32S+24Mg [53] 19F+40Ca [55] 32S+27Al [54] 35Cl+24Mg [57] 23Na+40Ca [55] 28Si+40Ca [55,60] 4)) in the fusion region III is shown as full darkred curve in both panels. The darkgreen dash-dotted curve in inset is due to the same kind of fit to the fusion region II. The background band around the best fit curve in the main panel is due to the errors on the fit parameters. Red dashed curve is the best fit curve from fig. 2. Blue dotted curve is the difference of both. Short-dashed darkred curve is due to the same kind of fit of the system excitation energy, i.e. E avail corrected for reaction Q-value per nucleon. general and it imparts the average dependence of fusion on E avail . Subtracting the two best fit curves allows to infer the main features of IF excitation function (blue dotted curve in fig. 5). IF process opens at E avail =1.6 MeV/nucleon, at about E avail = 4.3 MeV/nucleon it contributes equally to the total fusion cross section as CF, each of them amounting for about 0.08σ R , at the energy of vanishing CF, i.e. at E avail = 6.2 MeV/nucleon IF attains the maximum of almost 0.1σ R and slowly extincts until it vanishes at E avail = 13.2 MeV/nucleon. For mass symmetric systems, the above vanishing fusion energies correspond to E inc of about 25A and 53A MeV, respectively.

Within the accuracy of experimental fusion cross sections and the reliability of theoretical reaction cross sections the scaled fusion excitation function is reaction system independent. Since the extracted properties of the complete and incomplete components of fusion are affected neither by the system mass A sys , mass asymmetry α nor by the N sys /Z sys content, they may be considered as universal.

Summary. -To summarize, the systematics of evaporation-residue fusion cross sections far above the Coulomb barrier allowed us to infer a rather universal hop-5 mographic description (eq. ( 4)) of properly scaled complete and incomplete fusion excitation functions. From our analysis follows that the complete (incomplete) fusion vanishes at system available energy of 6 (13) MeV/nucleon and that incomplete fusion component amounts at most 10 % of total reaction cross section. The total fusion excitation functions of the Ar + Ar, Ar + Ni and Ni + Ni systems at incident energies higher than ∼ 15A MeV are well reproduced by the DYWAN microscopic model. The simulation results suggest that the nuclear transparency is at the origin of fusion disappearance.

Z.B. gratefully acknowledge the hospitality of the Faculté des sciences of Université de Nantes and Laboratoire Subatech.

Fig. 1 :

 1 Fig. 1: (Color online.) Normalized fusion cross sections σN plotted as a function of laboratory energy per nucleon Einc.I n panel a) are plotted all CF + IF data points from those works which have claimed that the fusion-fission component either does not exist or is negligible. To better resolve the stacked points in panels c) and b) are repeated subsets of the data for Asys ≤ 44 and 46 ≤ Asys ≤ 59, respectively. The inventoried systems are distinguished among them by symbols and a color code.

Fig. 2 :

 2 Fig. 2: (Color online.) σN as a function of E avail .T h em e a n i n g of symbols and colors may be inferred from fig. 1. The fit with the homographic function (eq. (4)) is shown as full red curve in both main panel and inset. The background band around the best fit curve is due to the errors on the fit parameters provided by the code used[70], see also in table1. Small circles are drawn over those data points which were rejected by the fitting procedure. A lightgray band for E avail < 1.04 MeV/nucleon delimits the region III from fusion regions I + II. Inset shows by darkgray circles those data points which survived the rejection through the iterative fitting procedure.

  by the thick red curve. Inset shows by darkgray circles those data points which survived the iterative fitting procedure. The complement to the full ensemble of σ N data, i.e. those data points which were rejected by fitting, are made visible in the main panel of fig.2by thin darkgray circles drawn over them.

Fig. 4 :

 4 Fig. 4: Density-profile contours in the center-of-mass reference frame projected onto the reaction plane for the Ni + Ni DY-WAN simulation at 60A MeV and b = 0.9 fm at a) contact (t =0 fm/c), b) maximal density (30 fm/c), c) starting of separation (60 fm/c), and d) separation (100 fm/c). The z-axis is along the projectile direction.

  (fig.5)) is quite

Fig. 5 :

 5 Fig.5: (Color online.) Complete fusion σN as a function of E avail (main panel) and as a function of the inverse of the same energy (inset) from those measurements which have reported data on both complete and incomplete fusion. The fit with the homographic function (eq. (4)) in the fusion region III is shown as full darkred curve in both panels. The darkgreen dash-dotted curve in inset is due to the same kind of fit to the fusion region II. The background band around the best fit curve in the main panel is due to the errors on the fit parameters. Red dashed curve is the best fit curve from fig.2. Blue dotted curve is the difference of both. Short-dashed darkred curve is due to the same kind of fit of the system excitation energy, i.e. E avail corrected for reaction Q-value per nucleon.

In this long publication we are going to also present a complete table of the raw experimental fusion cross section values as well as those of the calculated reaction cross sections.

Eq. (2) has been introduced by Bass to describe energy dependence of complete fusion and afterwards has been largely used to describe both complete and incomplete fusion excitation functions.