Ting Peng

Erwan Kerrien

Marie-Odile Berger

A SHAPE-BASED FRAMEWORK TO SEGMENTATION OF TONGUE CONTOURS FROM MRI DATA

Keywords: image segmentation, variational methods, shape, speech analysis, image registration

DIn this paper 1 , we propose a shape-based variational framework to curve evolution for the segmentation of tongue contours from MRI mid-sagittal images. In particular, we first build a PCA model on tongue contours of different articulations of a reference speaker, and use it as shape priors. The parameters of the curve representation are then manipulated to minimize an objective function. The designed energy integrates both global and local image information. The global term extracts roughly the object in the whole image domain; while the local term improves precision inside a small neighborhood around the contour. Promising results and comparisons with other approaches demonstrate the efficiency of our new model.

INTRODUCTION

Articulatory modeling of the vocal tract, or especially the tongue, is crucial for many applications. Speech training for hearing impaired children or in second language learning is one example, where the visual feedback can efficiently supplement the auditory feedback. Such a model also has potential interest for studies on articulatory synthesis. MRI provides us with a convenient and powerful tool for observing the internal articulators which are involved in speech production. In this study, we acquired 3D MRI data with a group of articulations from different speakers. With the help of the tongue model of a reference speaker, we aim to extract tongue contours from mid-sagittal images of a new speaker, and then to build his/her tongue model. This enables us, in the future, to compare tongue models between speakers, and explore how to adapt the reference speaker's tongue model to the new speaker. However, segmenting tongue contours is a hard task. First, the tongue is the most flexible organ of all the active articulators. It could move near other edges in the oral cavity, such as the palate, the lips and the teeth, which may disturb the segmentation process. Second, due to a quite long acquisition time of MRI data, the speaker is required to artificially sustain a sound. It is extremely difficult to maintain one's articulators always in a correct position during an acquisition. Boundaries may be smeared due to speaker movements. Third, even for the same articulation, tongue contours of different speakers could be very varied because of anatomical variations. Moreover, one may have a special pronunciation strategy. This greatly increases the difficulties of adaptation of the tongue model between individuals.

We briefly review previous work we believe to be the most relevant to the presented method. [START_REF] Maeda | Compensatory articulation during speech: evidence from the analysis and synthesis of vocal-tract shapes using an articulatory model[END_REF] proposed a popular model that has been frequently used in speech processing. A PCA-guided articulatory model is built to control tongue shapes in 2D. [START_REF] Leventon | Statistical shape influence in geodesic active contours[END_REF] developed active contours that use a shape model defined by a PCA. The curve evolves locally based on image gradients and curvature, and globally towards the MAP estimate of position and shape of the object. [START_REF] Tsai | A shape-based approach to the segmentation of medical imagery using level sets[END_REF] adopted an implicit representation of the segmenting curve and calculated pose parameters to minimize a region-based energy functional. In this paper, we introduce a robust variational framework for segmentation. Following the work in [START_REF] Chan | Active contours without edges[END_REF] and [START_REF] Li | Implicit active contours driven by local binary fitting energy[END_REF], we construct a total energy including both global and local image statistics. Shape priors are incorporated into segmentation via a PCA model. We describe this framework in section 2. The implementation details are discussed in section 3. In section 4, we present results obtained using the proposed framework, and make comparisons with other approaches. We conclude in section 5.

THE FRAMEWORK

Acquisitions of the data

We used 3D MRI data of four speakers: three males and one female, with strong morphological differences. A male speaker named M 0 is the reference speaker, because he has the most articulations in our database. The corpus of M 0 consists of a set of 39 sustained articulations designed so as to cover the range of French articulations as wide as possible. They are the vowels [i, e, E, a, O, o, u, y, ø, oe, ã, ε], and the consonants [S, s, k, p, t, l, r, f] in combination with one of three contexts [a, i, u]. A 3D MRI of a neutral position was also acquired. At the moment, the other three speakers only have parts of this complete corpus: the male speaker named M 1 has 34 articulations; the male speaker named M 2 has 20 articulations; and the female speaker named F 1 has only 10 vowel articulations. For each speaker, rigid registration is performed between the neutral and the other articulations to compensate for different positions between the acquisitions.

Curve representation

Though we are interested in buiding 3D models of the tongue in the near future, we only consider in this paper 2D models built in the midsagittal plane.

To represent curves in the process of segmenting an object in an image, we chose the PCA-based shape model proposed by [START_REF] Cootes | Statistical models of appearance for computer vision[END_REF]. PCA has the ability to capture the main variations of a training set while removing redundant information and noise. To build this shape model, we first performed 3D rigid registration based on mutual information between M 0 's articulations and his neutral position, and then drew manually the tongue contours of M 0 's 39 registered mid-sagittal images (see red lines in Fig. 1(a)). The contour starts from the bottom of the lingual frenulum and ends at the epiglottis, as shown in Fig. 1(b). The advantage of such a contour is that both extremities have physical point correspondences. These contours were used as the training set for the PCA. As a result, when using the p eigenvectors corresponding to the largest eigenvalues, a novel shape, C, of the same class as the training set, can be approximated by C(w) = C + p i=1 w i δC i , where C is the mean shape, and δC i is the eigenvector of the covariance matrix of the data. In this sense, each shape can be represented by a vector of eigencoefficients w.

Choosing p is crucial but difficult. p should be large enough to be able to capture the dominant shape variabilities presented in the training set, and to describe possible differences of tongue contours between speakers. On the other hand, p should not be too large in order to avoid undesired details which are true for a particular training shape. In all the experiments, we set empirically p equal to 15, whose fitting accuracy is 99.87%. In fact, with only 6 components, the fitting accuracy has already reached 97.6%. Although the first 6 PCA bases are enough to represent roughly the curve itself, we found that using more principal components is necessary to facilitate convergence to a proper minimum during energy minimization of the variational model.

Pose parameters

As the built model depends on the head position of the reference speaker, we need to roughly align the head of the considered and of the reference speeaker. This way, M 0 's tongue model is roughly positionned in the right way with respect to the considered speaker and the deformation capabilities of the model can be used to detect the actual boundaries of the tongue. Note that we do not aim at aligning the tongue shapes in this stage. We only want to aligne the heads so that the model can be efficiently used to detect the current shape. To perform such an alignment, a 2D affine registration based on mutual information is computed for a selected articulation (we used a vowel articulation). Using the same affine registration, for any other articulation, the target speaker's midsagittal image was thereby roughly registered to M 0 's corresponding mid-sagittal image.

The above registrations have tackled the scale and the head motion between speakers. However, due to different articulation strategies and different anatomical properties, translation could exist for the vocal tract. Hence, a translation vector r is added as a supplementary parameter. The new description of shapes is then given by

C(w, r; x) = C(x) + p i=1 w i δC i (x) + r 1 r 2 . (1)

Image segmentation

Given a curve C, we propose the following energy functional to address the problem of tongue contour extraction from a given image I. It is composed of two region-based energies:

E = αE G + E L , (2)
where the global energy term E G describes image information about pixels in the whole image domain Ω; while the local energy term E L introduces image information inside a small neighborhood of points along the contour C. α is a constant to balance contributions of the two terms. It is worth pointing out that the usual regularization term of boundary length is not needed in our model, since the PCA model can already ensure contour smoothness. Hereafter, we will discuss in detail E G and E L . The global energy term E G adopts the Chan-Vese model proposed in [START_REF] Chan | Active contours without edges[END_REF]. E G computes the optimal approximation of an image I as a piecewise constant binary function. It is written as

E G (C) = Cin I(x) -µ 2 dx + β Cout I(x) -ν 2 dx, (3)
where C in and C out denote respectively the region inside C and the region outside C; β is a weight; and the values of µ and ν, depending on the evolving curve C, are the averages of I in C in and in C out . Since our tongue contour is an open curve, we link the two extremities by a straight line to form a closed curve. We assume that the pixels inside (or outside) this closed curve belong to the region C in (or C out ). Thanks to the introduction of image information from the entire Ω, the initial curve does not necessarily have to be very close to the object to be detected. In other words, E G is capable of extracting objects roughly in a large scale. However, the segmentation will obviously not be precise if the image intensities in either C in or C out are not homogeneous. For this reason, we also need the local energy term E L to segment accurately objects in a relatively small scale.

E L takes the form of the local binary fitting energy proposed in [START_REF] Li | Implicit active contours driven by local binary fitting energy[END_REF]. The principle of this model is to insert a kernel function into the global binary fitting Chan-Vese model [START_REF] Chan | Active contours without edges[END_REF], so as to define a small neighborhood around the considered pixel x. E L is defined as

E L (C) = Ω Cin K(x -y) I(y) -u(x) 2 dy + β Cout K(x -y) I(y) -v(x) 2 dy dx, (4)
where the kernel function K with a localization property is chosen as a Gaussian kernel [START_REF] Li | Implicit active contours driven by local binary fitting energy[END_REF] with a scale parameter σ = 3.

To simplify the parameter setting, β is same as the one in Eq. ( 3), and tunes the effects coming from the pixels outside the contour. u(x) and v(x) (see details in [START_REF] Li | Implicit active contours driven by local binary fitting energy[END_REF]) are two values that fit image intensities in a neighborhood centered in point x, and thus vary in different x. Clearly, for each center point x, when the integrand of Eq. ( 4) is minimized, the contour C can be evolved more precisely to the object boundary according to local fitting criteria.

IMPLEMENTATION

We employ gradient descent algorithm to minimize E with respect to the PCA eigencoefficients w and the translation parameters r in Eq. ( 1). Since all the mid-sagittal images of non-reference speakers have been registered to M 0 's data, the initial contour C 0 for the evolution is M 0 's tongue contour for the corresponding sound. The initial w 0 is thus determined by projecting C 0 on the PCA bases, and r 0 = [0, 0].

For a curve C, we compute image statistics µ, ν, u(x) and v(x). We then derive the gradient of E, with respect to C:

∂E ∂C(x) =N(x) α I(x) -µ 2 -β I(x) -ν 2 + Ω K(y -x) I(x) -u(y) 2 dy -β Ω K(y -x) I(x) -v(y) 2 dy , (5)
where N(x) is an outward normal vector at point x. The evolution equations for w and r are

∂w i ∂t = - ∂E ∂C • δC i , ∀i ∈ {1, • • • , p} (6a)
∂r i ∂t = - ∂E ∂C • δr i , ∀i ∈ {1, 2} (6b)
with

δr 1 = [1, 0, • • • , 1, 0] and δr 2 = [0, 1, • • • , 0, 1].
The time evolutions of w and t use the forward Euler method. In order to guarantee reasonable shapes, we chose empirically the constrained interval [-5 √ λ i , 5 √ λ i ] for each w i , where λ i is the eigenvalue of the covariance matrix of the data. The updated eigencoefficients and translation parameters are then used to determine the updated location of the segmenting curve, which will be used to calculate local and global image statistics in the next iteration.

EXPERIMENTAL RESULTS

We applied the proposed framework to segment tongue contours of 3 non-reference speakers. In all the experiments, validation was performed by visual inspection of the results. Fig. 2 shows the results on M 1 's mid-sagittal images. Due to lack of space, we present here only parts of the results. The green curve denotes the initial contour,i.e. M 0 's tongue contour of the corresponding sound-, which is quite different from the ideal boundary for some sounds e.g. [pu], [fu], etc... The magenta curve denotes the final result obtained using our framework. The segmentation was very successful: the tongue contours of most sounds have been extracted accurately. We also obtained satisfactory results on M 2 's and F 1 's data, as shown in Fig. 3.It means that our framework accounts for strong morphological differnces. However, accuracy can be further improved when a clear boundary does not exist, e.g. M 2 's sound [ki] (Figs. 3(j)). Furthermore, two extremities of the contour still do not have perfect correspondences. For example, the left extremity of the contour for F 1 's sound [a] (Fig. 3(o)) actually corresponds to the apex.

In the proposed energy, there are two weights α and β to decide. The α value was fixed for a given speaker. α was generally small so that the local energy had dominant effects. If tongue contours between M 0 and the target speaker were very distinct, we set a larger value to alleviate convergence to local minima. In our experiments, for M 1 and M 2 , α = 0.08; while for F 1 , α = 0.045. On the other hand, β was normally

(f) [u] (g) [y] (h) [ø] (i) [oe] (j) [ã] (k) [ẽ] (l) [Sa] (m) [si] (n) [ka] (o) [ti] (p) [lu] (q) [ru] (r) [fu]
Fig. 2. Results on M 1 's mid-sagittal images. Green curve: initial contour; magenta curve: final result obtained using our model.

(a) M 2 -[i] (b) M 2 -[e] (c) M 2 -[a] (d) M 2 -[o] (e) M 2 -[u] (f) M 2 -[y] (g) M 2 -[ø] (h) M 2 -[oe] (i) M 2 -[Si] (j) M 2 -[ki] (k) M 2 -[t] (l) M 2 -[l] (m) F 1 -[i] (n) F 1 -[E] (o) F 1 -[a] (p) F 1 -[o] (q) F 1 -[ø] (r) F 1 -[oe]
Fig. 3. Results on M 2 's and F 1 's mid-sagittal images. Green curve: initial contour; magenta curve: final result obtained using our model. set equal to 1 for most experiments (73.8%), but when the initial contour was too far away from the desired contour, we needed to tune it by hand. This approach was thus quasiautomatic. How to develop a completely automatic algorithm will be a topic for future research.

To evaluate the performance of the new total energy, we compared it to the models in [START_REF] Chan | Active contours without edges[END_REF] and [START_REF] Li | Implicit active contours driven by local binary fitting energy[END_REF]. Fig. 4 shows some examples of these comparisons. Clearly, the result obtained using the Chan-Vese model [START_REF] Chan | Active contours without edges[END_REF] was not correct due to simplicity of the piecewise constant binary function; while the model in [START_REF] Li | Implicit active contours driven by local binary fitting energy[END_REF] could converge to undesired edges without the guide of global information.

CONCLUSIONS

We have proposed a novel variational framework for image segmentation. Our model energy combines local and global image statistics together to guide curve evolution. We incorporated shape priors via a statistical PCA model to increase robustness of the algorithm. Experiments demonstrate the effectiveness of the framework even for strong morphological differences. Comparisons to previous methods also show the importance of both energy terms. These first results seem to prove that when considereing a sufficient number of PCA components, the reference model brings sufficient priors to segment any speaker. This hypothesis has to be confirmed on more speakers. We plan to use the obtained results to build the model of the tongue for a new speaker, and hence to realize tongue model adaptation. However, we still have to solve the problem of point correspondences of the open tongue curve. We are currently working on adding certain constraints into our model to control the two contour extremities.

Fig. 1 .

 1 Fig. 1. An example of the mid-sagittal image and contours. (a): all the contours in the training set (red lines) and their mean contour (green line); (b): the mid-sagittal image of M 0 's sound [a] and its tongue contour drawn manually (red).

Fig. 4 .

 4 Fig.4. Comparisons. From left to right: results obtained on M 1 's sound [pu] respectively using the model in[START_REF] Chan | Active contours without edges[END_REF], the model in[START_REF] Li | Implicit active contours driven by local binary fitting energy[END_REF] and our proposed model.

This work is part of the ARTIS project funded by the French ANR program as project number EMER-001-01.


Active wide band antenna for under water tomography (1 GHz)1

C.Conessa and A.Joisel

A new active antenna has been designed to measure electromagnetic fields in water. It combines a differential wideband amplifier and a dipole, whose characteristics have been designed to provide a constant gain on the bandwidth of the antenna. The small size of the dipole reduces the mask effect. The designed antenna is a symmetrical reception antenna for the electromagnetic field measurement in water in the frequency range of 100 MHz to 1 GHz and it introduces few disturbances. A possible application will be the microwave imaging of immersed objects.

Introduction: This study was launched in order to reduce field measurement disturbances due to the presence of a receiving antenna in the vicinity of the immersed object to be characterized (Figure 1). When the receiving antenna is placed between the transmitter and the object under test, it results in a "mask effect". Our experimental set-up consists of a large water tank, two wideband biconic antennas [START_REF] Duchêne | Nonlinear inversions of immersed objects from laboratory-controlled data, Inverse Problems, Special section on the Electromagnetic Characterization of Buried Obstacles[END_REF] (transmission and reception), and a step-bystep motor for positioning control of the receiving antenna in order to obtain a synthetic antenna array. Our goal is to realize the equivalence of a sonar system for electromagnetic waves which characterizes immersed objects.

Nevertheless, due to its size, the receiving antenna causes a mask effect when it is located between this immersed object and the transmitting antenna, leading to mismatches between the model and experimental data which affect the images reconstructions. In order to reduce these mismatches, a new antenna which introduces a smaller mask effect has been developed. A similar approach has been used for astronomical studies [START_REF] Ardouin | Radiodetection signature of high-energy cosmic rays by the CODALEMA experiment[END_REF]. As uncommonly under water near-field measurements are not well studied, a first investigation of such systems has been done.

Antenna development: Using a short dipole instead of a thick wide band conventional antenna allows the mask effect to be reduced drastically. This dipole can be connected to a differential amplifier which is used as a wideband matching network and ideal balun. A short antenna ( l << λ ) presents two advantages: i) its omnidirectional pattern is quite independent of the frequency and ii) this antenna works like a field measurement device over a wide frequency band, while the drawbacks are i) the impedance of the dipole varies greatly with the frequency and ii) it has poor sensitivity specially for the low frequencies. Hence the dipole is connected to a high input impedance differential amplifier which acts as a perfect wide band balun.

Also, we calculated the length of the dipole to have the resonance frequency near the end of the amplifier's bandwidth at 900 MHz. AD8351, a CMS integrated circuit is selected for the amplification as it has a differential input and a stable gain between 1 to 1000 MHz. Moreover, its small size (2.1 cm) means that less disturbance is introduced to the system.

For practical reasons, a short transmission line is needed to connect the dipole to the amplifier input. The impedance of this line is 73 Ω, matched to the dipole only at the resonance frequency. As the dipole and the amplifier impedances are not matched to the transmission line over the operating frequency band, it is necessary to adjust the length of this line to minimize mismatch effects. In order to optimize the length of the line, the equivalent circuit of the "antenna-line-amplifier" system (Figure 2) has been simulated using Matlab. The impedance Z a of the antenna is given by Johnson and Jasik model [START_REF] Johnson | Antenna Engineering Handbook[END_REF].

Z a = R( ) kl -j       120       ln l a -1 cot kl -X(kl) ,
Where :

Z a is the impedance in ohms of a dipole which is a cylinder with a length of l = l 0 /2 and a radius of a. kl = 2 π (l/λ) (in radians) is an electric length and the functions R(kl) and X(kl)

given by [START_REF] Johnson | Antenna Engineering Handbook[END_REF]. The amplifier input impedance are given by data sheet of the selected integrated circuit [START_REF] Devices | Low Distortion, Differential RF/IF Amplifier, AD8351[END_REF]. The amplifier input is taken to be a 5 kΩ resistance in parallel with a 0.8 pF capacitor.

The transfer function of the system between the dipole connection and the device output is :

T (jω) = Z e Z e + Z a,L Re(Z a,L ) Re(Z a )
Where Z e is the input impedance of the amplifier given by:

Z e = R e 1 + j R e C e ω
And Z a, L is the impedance measured at a given position L from the dipole trough the line between the amplifier input and the antenna and it is given by :

Z a, L = Z d Z a + j Z d tan(β L) Z d + j Z a tan(β L)
Where Z d is the characteristic impedance of the line (73 Ω), β = 2π λ is the propagation constant and L is the length of the line.

With these elements, we study the influence of the line on the gain of the transfer function T(jω).

As we can see in Figure 3, the gain is higher when L is small.

In order to keep a constant gain over the whole operating bandwidth and to have an easier realization, a length of two centimeters is chosen. In this case, the gain is between -10 dB to -5 dB.

Structure of the line:

To obtain the desired impedance, simulations using CST microwave studio are done to study different structures. Following Transmission Line Design

Handbook [START_REF] Wadell | Transmission Line Design Handbook[END_REF], the coplanar guide with ground is selected as the most appropriate solution (Figure 4). With w = 2.4 mm and d = s = 0.5 mm, an impedance of 72.8 Ω is obtained.

Antenna test: First, we test the antenna in air inside an anechoic chamber.

The length of the dipole is set to be half of the wavelength of the transmitted signal (l = 18 cm). The gain versus the frequency has been confirmed although there are some losses. Next the length of the dipole is reduced to take into account the permittivity of water. In this case, it is difficult to be under the same conditions as in the anechoic chamber. Hence the transmission coefficient from the transmitter to the receiver for the active and the biconic antennas have been investigated (Figure 5). This study shows that the bandwidth is improved using the active antenna in underwater propagation.

The new bandwidth is around 600 to 800 MHz. Moreover, we have a better sensitivity especially for high frequencies.

Conclusion:

This study opens the path to new developments. The new active probe (Figure 6) is smaller than the biconic system, hence resulting in less disturbance. Its gain is also higher than the former system. Simple, cheap and easy to build, becomes possible to build an antenna array for immersed object imaging with low disturbance. The sensitivity is also better especially for high frequencies. As a consequence the spatial resolution of tomographic systems using such probes can be improved. Before realizing a probe array using this principle, the prototype could be improved, by optimizing other parameters such as dipole and differential line lengths.

Figure captions:

Figure 1 :Figure 2 :Figure 3 :Figure 4 :Figure 5 :Figure

 12345 Figure 1 : Experimental setup

Figure 4 Figure 5

 45 Figure 4

Figure 6

 6 Figure 6

Initiate on a demand from the GESMA (Groupe d'Etude Sous-Marine de l'Atlantique)


Guillaume Waignier

Estéban Duguepéroux

Anne-Franc ¸oise

Le Meur

Laurence Duchien

A Framework for Agile Development of Component-Based Applications

Agile development processes and component-based software architectures are two software engineering approaches that contribute to enable the rapid building and evolution of applications. Nevertheless, few approaches have proposed a framework to combine agile and component-based development, allowing an application to be tested throughout the entire development cycle. To address this problematic, we have built CALICO, a model-based framework that allows applications to be safely developed in an iterative and incremental manner. The CALICO approach relies on the synchronization of a model view, which specifies the application properties, and a runtime view, which contains the application in its execution context. Tests on the application specifications that require values only known at runtime, are automatically integrated by CALICO into the running application, and the captured needed values are reified at execution time to resume the tests and inform the architect of potential problems. Any modification at the model level that does not introduce new errors is automatically propagated to the running system, allowing the safe evolution of the application. In this paper, we illustrate the CALICO development process with a concrete example and provide information on the current implementation of our framework.

Introduction

In many application domains, software systems need to perpetually and rapidly evolve to cope with new user and technology requirements. Being able to modify existing systems or redesign new systems to rapidly take in account new functionalities or preferences has led to the proposition of several software engineering approaches such as the Agile software development methodology [START_REF] Alliance | Manifesto for agile software development[END_REF]. One of the key principles of Agile software development is to build software through an incremental and iterative process. Each iteration adds a new feature and produces a fully working system by going through the whole the software lifecycle, i.e., the analyze, develop and test phases. Another particularity of Agile development is that the testing activity is not just confined to the classical test phase but rather integrated throughout the entire lifecycle, meaning that the software is continuously tested throughout its development, from its specifications to the final running system, in order to augment the overall software system quality.

Another software engineering approach that contributes to facilitating the rapid development of software systems is the use of component-based software architectures. In this context, the overall structure of the application is first described with an architecture description language (ADL) [START_REF] Medvidovic | A classification and comparison framework for software architecture description languages[END_REF]. Such description highlights the needed components and their assembly, which facilitates the understanding and analysis of the application's properties, such as behavioral or quality of service properties. If the specifications are coherent, the application is eventually instantiated, deployed and executed to be tested.

Although Agile software development and component-based software engineering (CBSE) may appear quite different approaches, some works [START_REF] Stojanovic | Component-oriented agile software development[END_REF][START_REF] Radinger | Agile software development for component based software engineering[END_REF] have identified that both approaches could benefit to each other, CBSE bringing for example the capability of building large software and enhancing reusability, and Agile development offering more flexible development processes for shorter time-to-market products. Nevertheless we believe that there is still a bridge between these two approaches, one reason being the lack of component frameworks that allow incremental and iterative development processes, as well as throughout-lifecycle testing.

To address this problematic, we have developed a model-based framework, named CALICO, that enables architects to design and test component-based systems in an iterative and uniformed process [START_REF] Waignier | A Model-Based Framework for Statically and Dynamically Checking Component Interactions[END_REF][START_REF] Waignier | A model-based framework to design and debug safe component-based autonomic systems[END_REF]. CALICO allows software architects to specify their architectures as models, and to analyze them with respect to application and platform constraints. Our approach enables the testing of the system throughout the system lifecycle. More concretely, CALICO analyses architecture models and creates contracts by composing contractual application properties, e.g., behavioral, dataflow, QoS properties. This composition allows compatible and incompatible interaction to be identified, as well as partially compatible interactions, which require runtime checking [START_REF] Waignier | Architectural Specification and Static Analyses of Contractual Application Properties[END_REF]. When runtime checking is needed, CALICO automatically instruments the application to reify runtime information to complete the resolution of the partially compatible interaction contract and thus detects if the given interaction may lead to an error. By using this framework in iterative software design processes, architects get design feedback, i.e., information on identified interaction errors, and can then modify the models accordingly. Each modification performed on the model is propagated to the running system since CALICO ensures the synchronization between the model and the runtime system, both of which thus coexist during the whole application development. Furthermore, the solution offered by CALICO is generic regarding underlying platforms, allowing component platforms to benefit from all the analyses integrated into CALICO.

The rest of this paper is organized as follows. Section 2 gives an overview of the CALICO iterative and incremental development process. Section 3 illustrates with a concrete scenario the CALICO approach. Finally, Section 4 provides some information about the current status of our framework implementation.

CALICO Overview

CALICO is composed of two levels: a model level and a platform level as shown in Figure 1. The model level is independent of any component-based or service-oriented platform. It contains the CALICO Architecture Description metamodels that enable an architect to describe the structure and the properties, i.e., structural, behavioral, dataflow and QoS properties, of an application. It is also possible to specify some contextual adaptation rules, independently of any platform, in order to allow the debugging of autonomic systems. The platform level holds the running system on a target platform.

The iterative and incremental development process of CALICO, illustrated in Figure 1, is as follows :

(1) Design : The architect specifies the design of the desired application using the CALICO metamodels. The system structure metamodel enables architects to describe the structure of their architecture, independently of any component platform. CALICO provides also four contract metamodels to allow architects to specify structural, behavioral, dataflow and QoS properties for each component.

(2) Static analysis : The interaction analysis tool checks the coherence of the system architecture. For each partially compatible interaction, a test to be performed at execution time is automatically inserted into the CALICO debug metamodel. For each incompatible interaction, the architect is notified of the problem and he/she may thus provide some modification of the application design. As long as some incompatible interactions remain, the next steps of the development process can not be reached. Once all of the problems are fixed, the architect specifies the runtime platform on which the application is to be executed and CALICO verifies that the specifications do not go against the platform constraints in order to make sure that the application can be indeed deployed on that specific platform.

(3) Code generation : If a component or service does not already exist, then the generation tool generates code skeleton such that only business code needs to be provided by the developers.

(4) Instrumentalisation : This step makes the link between the static analysis and the dynamic checks of the application at runtime. The instrumentation tool takes the debug model as input and automatically instruments the application code to enable the capture of the needed runtime information to complete the resolution of the partially compatible interaction. This instrumentalisation relies on an aspect-oriented approach and is independent of the underlying platform.

(5) Instantiation : The loader instantiates the application on the target platform as described by the architect's structural model. Concretely, the running system is created incrementally by calling the appropriate sequence of system construction operations, such as creating/removing components and connectors.

(6) Reification : As the testers run the application in different execution contexts, the instrumented application automatically reifies any context changes and monitored information.

(7) Dynamic debugging : During the debugging phase, the debug tool analyzes the information reified by the running system and triggers when needed the tests contained in the debugging model. The architect is notified each time an error is detected, allowing him/her to correct the application design. Other debugging action rather than the notification action maybe chosen, such as logging the information into a file, or executing a reconfiguration script that will automatically modify the design and trigger the step 2 of the process. This latter case may be useful to tune/test adaptation policies for autonomic system.

(8) Evolution of the design : The architect can modify the design with respect to the debugging information if problems have occurred. They can also adapt at anytime the design of the application to address new user or application requirements. After any modification, the development cycle iterates again starting at step 2.

Illustrative Example

To illustrate the agile development process offered by CALICO, we use an example of architecture in the context of the French Personal Health Record system (PHR) [START_REF] Nunziati | Personal health record[END_REF]. PHR is the French personal health record system that is intended to provide health-care professionals with the information needed for their patients care. Figure 2 represents a possible architecture of the PHR system. All medical information, (such as biological analyses, X-rays, medications, etc.), will be stored in distributed databases and will be made accessible through an on-line interface Client.

In order to build a robust PHR application, architects need to be able to express several application properties. A first requirement of this system architecture is related to authentication issues since not everybody should have access to anybody's health records. The architecture of this system must thus provide some authentication mechanism. The Authentication architecture element logs a health-care professional in and returns a session ticket through the functionality getTicket that is offered by SessionServer. For security reason, the functionality getTicket can be used only by the element Authentication to avoid that an unauthenticated user get a session ticket. Finally the session ticket must be validated by the SessionServer before retrieving any medical data from the database.

Another requirement is the high reliability of the system. Such system has to be able to handle very heterogeneous medical information, going from light-weight text records to gigabytes of echographies. Furthermore, the devices used to display this information are also heterogeneous. They range from desktop computers with high-quality largescreen monitors and gigabyte network connexions to simple PDAs with small screens and low-bandwidth GPRS network connexion. Handling such data in a reliable way is critical because the system must be able to determine if a given data can be displayed appropriately with no loss of information, as well as in which time-frame, depending on the available resources and amount of information to display. For example, a dataflow constraint may express that medical data received on a terminal of type PDA Nokia N800 should be less than 10 megaoctets. Another constraint can also specify that only text or jpg documents can be read on that terminal.

Overall the constraints may evolve in time or just not reflect exactly one given execution context. There is thus a need to iterate the whole process to check if the declared application constraints can be all checked, statically or dynamically.

(1) The architect specifies the architecture and the properties of the PHR application. For example, the first requirement mentioned above can be specified using the structural contract metamodel. (2) The overall coherence of the constraints is statically verified. A partially compatible interaction is detected between the MedicalServer and the PDS since data sent by the server could be greater than 10 megaoctets or in a different format than txt or jpg. Accordingly CALICO adds some rules to validate in the debug model. These rules specify that the size and the data type must be captured at runtime.

(3) Code skeletons are generated and developers can provide the business code of each components.

(4) Following the information contained in the debug model, the application is automatically modified to capture the size and the type of the medical data that enters the PDA.

(5) The application is deployed on the target application. (7) The debug tool resumes the interaction compatibility checks that were partially compatible. In the case of the druggist, no error is detected, whereas for the radiologist, the analyse indicates that the data are too large for the PDA.

(8) The architect can accordingly modify the application design by inserting a new component DataConverter between the PDA and the GlobalSearch component in order to reduce the size of a too large radiography.

The whole process is then iterated again. If no error is detected statically, the new component DataConverter is automatically integrated into the already deployed application, and new test scenarios may be executed.

Conclusion and Current Implementation Status

CALICO is a model-based framework that enables the design and debug of systems in an iterative and incremental way, bridging a little more the gap between component-based software engineering and agile development approaches. Our framework is generic and highly extensible. All metamodels for specifying the structure, the application properties and the adaptation rules are independent of any underlying platform. This enables architects to perform various architecture analyses on their applications even if the underlying component or service framework does not provide any verification tools.

The current implementation of CALICO is developed in Java. All CALICO metamodels are implemented with the Eclipse Modeling Framework (EMF). A graphical editor, implemented with the Graphical Modeling Framework (GMF), enables the architect to edit the model during the whole development cycle.

We have integrated several existing tools to verify the coherence of the component interactions in term of structural, behavioral, dataflow and quality of service properties. Structural constraints are expressed in OCL [START_REF]Object Management Group: Object Constraint Language (OCL)[END_REF], using the EMF-OCL library. Behavioral specifications are based on existing process algebra, such as CSP [START_REF] Hoare | Communicating Sequential Processes[END_REF], FSP [START_REF] Magee | Behavioral analysis of software architecture using ltsa[END_REF], SFSP. The current implementation uses the Fractal behavioral protocol checker [START_REF] Barros | Behavioural models for distributed fractal components[END_REF] to verify that a given component composition does not introduce a deadlock. We have developed a dataflow analysis based on the algorithm of constant propagation in partial program validation [START_REF] Kildall | A unified approach to global program optimization[END_REF]. The QoS metamodel has been inspired by the QML [START_REF] Frolund | QML: A Language for Quality of Service Specification[END_REF] and WSLA [START_REF][END_REF] approaches. The associated analysis is based on prediction of quality property in a workflow of WEB services [START_REF] Xiangpeng | A qos view of web service choreography[END_REF]. Furthermore, application instrumentation has been implemented with Spoon [START_REF] Pawlak | Spoon: Compile-time annotation processing for middleware[END_REF]. The sensor framework Wildcat [START_REF] David | Wildcat: a generic framework for context-aware applications[END_REF] has been integrated in CALICO. Our current implementation supports four component platforms (Fractal [START_REF] Bruneton | An open component model and its support in Java[END_REF], OpenCCM [START_REF] Coulson | Opencom v2: A component model for building systems software[END_REF], OpenCOM [START_REF] Briclet | OpenCCM : une infrastructure à composants pour le déploiement d'applications à base de composants CORBA[END_REF] and FraSCAti [START_REF] Seinturier | Reconfigurable sca applications with the frascati platform[END_REF]) and one service-oriented platform(Web services [START_REF] Erl | Service-oriented Architecture: Concepts, Technology, and Design[END_REF]). CALICO has been carefully designed to allow new extensions in terms of support for new platforms, new QoS sensors and new kinds of debugging actions.

We have performed benchmarks on our implementation and showed that CALICO is usable to design reliable large systems up-to 10000 components, which is the maximum load of most runtime platforms.

CALICO is still being developed, to support more extensions. The current implementation is freely available at http://calico.gforge.inria.fr.

Figure 1 :

 1 Figure 1: Overview of CALICO iterative development process

Figure 2 :

 2 Figure 2: Structure of the PHR application

( 6 )

 6 At this step different execution contexts are tested. One may consists in the use of the PHR application by a druggist, who typically uses the PHR only to consult text documents. Another test scenario considers a radiologist. During the test scenario execution, monitored informations are reified.