{"id":199,"date":"2022-02-01T18:09:14","date_gmt":"2022-02-01T18:09:14","guid":{"rendered":"https:\/\/9h15.net\/activ\/?p=199"},"modified":"2022-02-01T18:09:25","modified_gmt":"2022-02-01T18:09:25","slug":"c-et-c-tp3","status":"publish","type":"post","link":"https:\/\/9h15.net\/activ\/c-et-c-tp3\/","title":{"rendered":"C et C++ TP3"},"content":{"rendered":"<p><code>Par O. Bailleux, Ma\u00eetre de conf\u00e9rences HDR \u00e0 l'universit\u00e9 de Bourgogne.<\/code><\/p>\n<h1><a id=\"tomographie-discr%C3%A8te-partie-1\" class=\"anchor\" aria-hidden=\"true\"><span class=\"octicon octicon-link\"><\/span><\/a>Tomographie discr\u00e8te &#8211; partie 1<\/h1>\n<p>Ce TP est la premi\u00e8re partie d&rsquo;un travail qui sera men\u00e9 sur plusieurs s\u00e9ances et dont le but est de r\u00e9aliser une application permettant de reconstituer une image \u00e0 partir d&rsquo;une signature repr\u00e9sentant les nombres de pixels actifs sur les lignes et colonnes. Le principe peut \u00eatre \u00e9tendu aux diagonales, mais ce sera l&rsquo;objet d&rsquo;un prochain TP.<\/p>\n<h2><a id=\"1-le-probl%C3%A8me-de-la-tomographie-discr%C3%A8te\" class=\"anchor\" aria-hidden=\"true\"><span class=\"octicon octicon-link\"><\/span><\/a>1. Le probl\u00e8me de la tomographie discr\u00e8te<\/h2>\n<p>Bien qu&rsquo;il ait des applications tout \u00e0 fait s\u00e9rieuses, on peut pr\u00e9senter ce probl\u00e8me sous la forme d&rsquo;un petit jeu. Observez la grille ci-dessous.<\/p>\n<p><img decoding=\"async\" src=\"https:\/\/9h15.net\/activ\/wp-content\/uploads\/2022\/02\/1.png\" alt=\"image-20220128101830285\" \/><\/p>\n<p>Le but du jeu est de placer 14 jetons sur la grille de mani\u00e8re \u00e0 ce que le nombre de jetons sur chaque ligne et colonne soit \u00e9gal \u00e0 la valeur indiqu\u00e9e en face.<\/p>\n<p>Essayez de trouver une solution, mais sans y passer trop de temps, juste pour prendre conscience de la difficult\u00e9 du probl\u00e8me.<\/p>\n<div class=\"spoiler-wrap\">\n\t\t\t\t<div class=\"spoiler-head folded\">&quot;R\u00e9ponse&quot;<\/div>\n\t\t\t\t<div class=\"spoiler-body\"><\/p>\n<p>Voici une solution, mais il y en a peut \u00eatre d&rsquo;autres. Il est facile de v\u00e9rifier si une configuration de jetons est une solution, mais plus difficile en pratique de rechercher une solution.<\/p>\n<p><img decoding=\"async\" src=\"https:\/\/9h15.net\/activ\/wp-content\/uploads\/2022\/02\/2.png\" alt=\"image-20220128102720927\" \/><\/p>\n<p><\/div>\n\t\t\t<\/div>\n<p>On peut consid\u00e9rer que les jetons sont les pixels actifs d&rsquo;une image (noirs ou blancs selon la convention utilis\u00e9e). La liste des nombres de pixels actifs sur les diff\u00e9rentes colonnes, (1,6,2,2,2,1) et celle des nombres de pixels actifs sur les diff\u00e9rentes lignes, (2,5,2,2,2,1) constituent ce que nous appellerons la <strong>signature<\/strong> de l&rsquo;image.<\/p>\n<p>Le probl\u00e8me de la tomographie discr\u00e8te consiste, \u00e9tant donn\u00e9e une signature, \u00e0 produire une image en coh\u00e9rence avec cette signature. Le probl\u00e8me se g\u00e9n\u00e9ralise \u00e0 des grilles, carr\u00e9e ou rectangulaires, de toutes dimensions. Toute image \u00e0 une signature, mais au del\u00e0 d&rsquo;une certaine taille de grille, certaines signatures correspondent \u00e0 plusieurs images.<\/p>\n<p>Voici un exemple de signature correspondant \u00e0 deux images diff\u00e9rentes.<\/p>\n<p><img decoding=\"async\" src=\"https:\/\/9h15.net\/activ\/wp-content\/uploads\/2022\/02\/3.png\" alt=\"image-20220128105229866\" \/><\/p>\n<p>On peut am\u00e9liorer la fiabilit\u00e9 de la reconstruction en ajoutant \u00e0 la signature les nombres de pixels actifs dans les diagonales montantes et descendantes.<\/p>\n<p><img decoding=\"async\" src=\"https:\/\/9h15.net\/activ\/wp-content\/uploads\/2022\/02\/4.png\" alt=\"image-20220128110118526\" \/><\/p>\n<p>Dans un premier temps, nous nous int\u00e9resserons \u00e0 la variante simple du probl\u00e8me bas\u00e9e sur des signatures lignes \/ colonnes.<\/p>\n<h2><a id=\"2-repr%C3%A9sentations-des-donn%C3%A9es\" class=\"anchor\" aria-hidden=\"true\"><span class=\"octicon octicon-link\"><\/span><\/a>2. Repr\u00e9sentations des donn\u00e9es<\/h2>\n<h3><a id=\"repr%C3%A9sentation-d-une-image\" class=\"anchor\" aria-hidden=\"true\"><span class=\"octicon octicon-link\"><\/span><\/a>Repr\u00e9sentation d&rsquo;une image<\/h3>\n<p>Nous allons d&rsquo;abord travailler sur la repr\u00e9sentation d&rsquo;une image sous la forme d&rsquo;un tableau d&rsquo;entiers de type <code>char<\/code> \u00e0 <strong>une<\/strong> dimension. La figure ci-dessous illustre sur un exemple le principe utilis\u00e9.<\/p>\n<p><img decoding=\"async\" src=\"https:\/\/9h15.net\/activ\/wp-content\/uploads\/2022\/02\/5.png\" alt=\"image-20220128114919676\" \/><\/p>\n<p>Voici la d\u00e9claration d&rsquo;un tableau repr\u00e9sentant une image de 6 par 6 ne contenant que des pixels \u00e9teints.<\/p>\n<pre><code class=\"language-C\">int dim = 6;\nchar image[dim*dim] = {0};\n<\/code><\/pre>\n<h3><a id=\"repr%C3%A9sentation-d-une-signature\" class=\"anchor\" aria-hidden=\"true\"><span class=\"octicon octicon-link\"><\/span><\/a>Repr\u00e9sentation d&rsquo;une signature<\/h3>\n<p>La signature de l&rsquo;image \u00e0 reconstituer sera constitu\u00e9e de deux tableaux repr\u00e9sentant respectivement les nombres de pixels actifs sur les lignes et sur les colonnes.<\/p>\n<pre><code class=\"language-C\">int dim = 6;\nint sLignes[dim] =   {2,5,2,2,2,1};\nint sColonnes[dim] = {1,6,2,2,2,1};\n<\/code><\/pre>\n<h2><a id=\"3-fonctions%C3%A0-r%C3%A9aliser\" class=\"anchor\" aria-hidden=\"true\"><span class=\"octicon octicon-link\"><\/span><\/a>3. Fonctions \u00e0 r\u00e9aliser<\/h2>\n<h3><a id=\"affichage-d-une-image\" class=\"anchor\" aria-hidden=\"true\"><span class=\"octicon octicon-link\"><\/span><\/a>Affichage d&rsquo;une image<\/h3>\n<p>Pour la mise au point du programme et la v\u00e9rification du r\u00e9sultat, nous aurons besoin d&rsquo;une fonction permettant d&rsquo;afficher une image.<\/p>\n<pre><code class=\"language-C\">\/\/ Affiche l'image d\u00e9sign\u00e9e par img, \n\/\/ de largeur et hauteur dim.\nvoid afficheImage(char* img, int dim);\n<\/code><\/pre>\n<p>La fonction auxiliaire suivante pourra \u00eatre utilis\u00e9e par la fonction <code>afficheImage<\/code> et par d&rsquo;autres fonctions que vous aurez \u00e0 d\u00e9finir.<\/p>\n<pre><code class=\"language-C\">\/\/ Retourne la valeur du pixel situ\u00e9 en ligne lgn et\n\/\/ en colonne col dans l'image de dimension dim\n\/\/ d\u00e9sign\u00e9e par img \nint litPixel(char* img, int dim, int lgn, int col);\n<\/code><\/pre>\n<p>La fonction suivante suivant permet de tester la fonction <code>afficheImage<\/code> en lui faisant afficher une image de test.<\/p>\n<pre><code class=\"language-C\">void test_AfficheImage()\n{\n    char image[] =\n    {\n        1,0,1,1,\n        1,0,1,1,\n        1,0,1,0,\n        1,1,1,0\n    };\n    afficheImage(image, 4);\n}\n<\/code><\/pre>\n<p>L&rsquo;affichage attendu est le suivant :<\/p>\n<pre><code class=\"language-plain_text\">    XX    XX XX\n    XX    XX XX\n    XX    XX \n    XX XX XX  \n<\/code><\/pre>\n<p>Horizontalement, chaque pixel est repr\u00e9sent\u00e9 par le motif <code>XX<\/code> et les pixels sont s\u00e9par\u00e9s par des espaces.<\/p>\n<h3><a id=\"v%C3%A9rification-de-la-signature-d-une-image\" class=\"anchor\" aria-hidden=\"true\"><span class=\"octicon octicon-link\"><\/span><\/a>V\u00e9rification de la signature d&rsquo;une image<\/h3>\n<h4><a id=\"fonctions%C3%A0-d%C3%A9finir\" class=\"anchor\" aria-hidden=\"true\"><span class=\"octicon octicon-link\"><\/span><\/a>Fonctions \u00e0 d\u00e9finir<\/h4>\n<p>La fonction suivante permet de v\u00e9rifier si une image est compatible avec une signature<\/p>\n<pre><code class=\"language-C\">\/\/ V\u00e9rifie si la signature constitu\u00e9e des tableaux d\u00e9sign\u00e9s\n\/\/ par sLgn (pour les lignes) et sCol (pour les colonnes)\n\/\/ est compatible avec l'image de dimension dim d\u00e9sign\u00e9e\n\/\/ par img. Retourne vrai si image et signature compatibles.\nint verifSign(char* img, int* sLgn, int* sCol, int dim)\n<\/code><\/pre>\n<p>Cette fonction fera appel \u00e0 deux fonctions auxiliaires : une pour compter le nombre de pixels actifs sur une colonne donn\u00e9e et une autre pour compter le nombre de pixels actifs sur une ligne donn\u00e9e.<\/p>\n<pre><code class=\"language-C\">\/\/ Retourne le nombre de pixels actifs sur la ligne lgn de\n\/\/ l'image de dimension dim d\u00e9sign\u00e9e par img\nint compteLigne(char* img, int lgn, int dim);\n<\/code><\/pre>\n<pre><code class=\"language-C\">\/\/ Retourne le nombre de pixels actifs sur la colonne col\n\/\/ de l'image de dimension dim d\u00e9sign\u00e9e par img\nint compteCol(char* img, int col, int dim);\n<\/code><\/pre>\n<p>Vous devez non seulement impl\u00e9menter ces fonctions, mais aussi r\u00e9aliser les fonctions de test associ\u00e9es en suivant les instructions donn\u00e9es dans la section suivante.<\/p>\n<h4><a id=\"test-des-fonctions\" class=\"anchor\" aria-hidden=\"true\"><span class=\"octicon octicon-link\"><\/span><\/a>Test des fonctions<\/h4>\n<p>Une <strong>bonne pratique<\/strong> de d\u00e9veloppement consiste \u00e0 <strong>tester chaque fonction apr\u00e8s l&rsquo;avoir d\u00e9finie et avant de commencer \u00e0 impl\u00e9menter d&rsquo;autres fonctions<\/strong>. Cela suppose d&rsquo;impl\u00e9menter la fonction <code>compteLigne<\/code> et la fonction <code>compteCol<\/code> <strong>avant<\/strong> la fonction <code>verifSign<\/code> qui les utilise.<\/p>\n<p>D&rsquo;une mani\u00e8re g\u00e9n\u00e9rale, toute fonction a des donn\u00e9es d&rsquo;entr\u00e9e et des donn\u00e9es de sortie.<\/p>\n<p>Les <strong>donn\u00e9es d&rsquo;entr\u00e9e<\/strong> d&rsquo;une fonction peuvent \u00eatre :<\/p>\n<ul>\n<li>Les valeurs de ses param\u00e8tres, appel\u00e9es arguments,<\/li>\n<li>Toutes les autres informations prises en compte par la fonction, qui peuvent \u00eatre par exemple dans des variables globales ou dans des variables point\u00e9es par des arguments de la fonction.<\/li>\n<\/ul>\n<p>Les <strong>donn\u00e9es de sortie<\/strong> peuvent \u00eatre :<\/p>\n<ul>\n<li>La valeur de retour,<\/li>\n<li>Toutes les informations modifi\u00e9es par l&rsquo;ex\u00e9cution de la fonction, qui peuvent \u00eatre par exemple des donn\u00e9es situ\u00e9es dans des variables globales ou dans des variables point\u00e9es par des arguments de la fonction.<\/li>\n<li>Les affichages r\u00e9alis\u00e9s par la fonction, si applicable.<\/li>\n<\/ul>\n<p>Pour tester une fonction, il faut des <strong>donn\u00e9es de test<\/strong>, c&rsquo;est \u00e0 dire des donn\u00e9es d&rsquo;entr\u00e9e avec lesquelles on va ex\u00e9cuter la fonction et v\u00e9rifier que les donn\u00e9es de sortie sont correctes. Ces donn\u00e9es de tests ne doivent pas \u00eatre complaisantes. Elles doivent \u00eatre con\u00e7ues dans le but de provoquer une erreur si la fonction est mal programm\u00e9e.<\/p>\n<p>Le test d&rsquo;une fonction est appel\u00e9 <strong>test unitaire<\/strong>. Deux approches sont possibles pour r\u00e9aliser un tel test :<\/p>\n<ul>\n<li><strong>L&rsquo;approche artisanale<\/strong>, dans laquelle on v\u00e9rifie visuellement, par des affichages, que les donn\u00e9es de sorties sont correctes.<\/li>\n<li><strong>L&rsquo;approche automatis\u00e9e<\/strong>, dans laquelle une <strong>fonction de test<\/strong> appelle plusieurs fois la fonction \u00e0 tester avec des donn\u00e9es de tests pr\u00e9-\u00e9tablies ou produites al\u00e9atoirement, v\u00e9rifie que les r\u00e9sultats sont corrects, et retourne un bool\u00e9en indiquant si le test a \u00e9t\u00e9 r\u00e9ussi ou si une erreur a \u00e9t\u00e9 d\u00e9tect\u00e9e. Dans ce dernier cas, un message d\u00e9crivant l&rsquo;erreur et la donn\u00e9e probl\u00e9matique peut \u00eatre produit. (Dans les grosses applications d\u00e9velopp\u00e9es en \u00e9quipe, ce message peut \u00eatre \u00e9crit dans un fichier ou m\u00eame envoy\u00e9 automatiquement au d\u00e9veloppeur ayant impl\u00e9ment\u00e9 la fonction d\u00e9faillante.)<\/li>\n<\/ul>\n<p>Examinons ces deux approches avec la fonction <code>compteLigne<\/code>.<\/p>\n<h5><a id=\"test-artisanal\" class=\"anchor\" aria-hidden=\"true\"><span class=\"octicon octicon-link\"><\/span><\/a>Test artisanal<\/h5>\n<p>Voici un exemple de fonction de test &quot;artisanale&quot; de la fonction <code>compteLigne<\/code>, qui compte le nombre de pixels actifs sur une ligne d&rsquo;une image.<\/p>\n<pre><code class=\"language-C\">void test__compteLigne()\n{\n    char image[] =\n    {\n        1,0,1,1,\n        1,0,0,1,\n        1,0,1,0,\n        0,0,1,0\n    };\n    printf(&quot;\\nLes valeurs obtenues sont : &quot;);\n    for(int i=0; i&lt;4; i++)\n    {\n        printf(&quot;%d &quot;, compteLigne(image,i,4));\n    }\n    printf(&quot;\\nLes valeurs correctes sont : 3 2 2 1\\n&quot;);\n}\n<\/code><\/pre>\n<p>La donn\u00e9e de test est une image pr\u00e9-d\u00e9finie par l&rsquo;initialisation d&rsquo;un tableau. On appelle la fonction <code>compteLigne<\/code> pour chaque ligne de cette image et on affiche la valeur retourn\u00e9e. La personne qui r\u00e9alise le test v\u00e9rifie que les affichages produits correspondent bien aux valeurs attendues.<\/p>\n<h5><a id=\"test-automatis%C3%A9\" class=\"anchor\" aria-hidden=\"true\"><span class=\"octicon octicon-link\"><\/span><\/a>Test automatis\u00e9<\/h5>\n<p>Voici un exemple de fonction qui automatise le test de la fonction <code>compteLigne<\/code>.<\/p>\n<pre><code class=\"language-C\">int test_compteLigne()\n{\n    char image[] =\n    {\n        1,0,1,1,\n        1,0,0,1,\n        1,0,1,0,\n        0,0,1,0\n    };\n    int sLgn[] = {3,2,2,1};\n    \n    for(int i=0; i&lt;4; i++)\n    {\n        if(compteLigne(image,i,4) != sLgn[i])\n        {\n            printf(&quot;Test de compteLigne : erreur ligne %d\\n&quot;,i);\n            return 0;\n        }\n    }\n    return 1;\n}\n<\/code><\/pre>\n<p>Non seulement cette fonction de test appelle la fonction \u00e0 tester avec diff\u00e9rentes donn\u00e9es d&rsquo;entr\u00e9e (une m\u00eame image, mais plusieurs num\u00e9ros de lignes), mais elle v\u00e9rifie si le r\u00e9sultat retourn\u00e9 est correct. Bien s\u00fbr les r\u00e9sultats attendus ont \u00e9t\u00e9 produits par un autre moyen que l&rsquo;appel \u00e0 la fonction \u00e0 tester. Ici, la personne ayant d\u00e9fini la fonction de test a compt\u00e9 les 1 dans les repr\u00e9sentations des lignes de l&rsquo;image de test.<\/p>\n<h5><a id=\"quel-type-de-test-impl%C3%A9menter\" class=\"anchor\" aria-hidden=\"true\"><span class=\"octicon octicon-link\"><\/span><\/a>Quel type de test impl\u00e9menter ?<\/h5>\n<p>Dans le cadre d&rsquo;un TP ponctuel, d&rsquo;une dur\u00e9e limit\u00e9, des fonctions de test artisanales sont suffisantes car le temps suppl\u00e9mentaire pass\u00e9 \u00e0 r\u00e9aliser des tests automatis\u00e9s ne serait pas rentabilis\u00e9 par une utilisation ult\u00e9rieure des fonctions de tests d\u00e9velopp\u00e9es.<\/p>\n<p>Dans le cadre de ce TP, vous devez r\u00e9aliser les fonctions de test artisanales et automatis\u00e9es des fonctions <code>compteCol<\/code> et <code>verifSign<\/code>. Pour les autres fonctions, seul un test artisanal est demand\u00e9.<\/p>\n<h3><a id=\"recherche-d-une-image-correspondant%C3%A0-une-signature\" class=\"anchor\" aria-hidden=\"true\"><span class=\"octicon octicon-link\"><\/span><\/a>Recherche d&rsquo;une image correspondant \u00e0 une signature<\/h3>\n<p>Il existe diff\u00e9rents moyens pour rechercher une image correspondant \u00e0 une signature connue. Les plus faciles \u00e0 programmer sont les moins efficaces et ne permettent de traiter que de petites images. Les moyens propos\u00e9 ici pourront \u00eatre exploit\u00e9s avec des images de 4 par 4.<\/p>\n<h4><a id=\"recherche-al%C3%A9atoire\" class=\"anchor\" aria-hidden=\"true\"><span class=\"octicon octicon-link\"><\/span><\/a>Recherche al\u00e9atoire<\/h4>\n<p>Le principe est de produire une image al\u00e9atoire, puis de v\u00e9rifier si elle correspond \u00e0 la signature donn\u00e9e, et de recommencer tant qu&rsquo;une image compatible n&rsquo;est pas produite. On peut donner une limite du nombre d&rsquo;essais \u00e0 r\u00e9aliser.<\/p>\n<p>Une fonction auxiliaire doit \u00eatre d\u00e9finie et test\u00e9e de mani\u00e8re artisanale :<\/p>\n<pre><code class=\"language-C\">\/\/ Cr\u00e9e une image al\u00e9atoire de dimension dim dans\n\/\/ le tableau d\u00e9sign\u00e9 par img.\nvoid genRandImage(char* img, int dim);\n<\/code><\/pre>\n<p>Voici la d\u00e9claration de la fonction de recherche :<\/p>\n<pre><code class=\"language-C\">\/\/ Recherche une image de dimension dim compatible avec la signature\n\/\/ d\u00e9finie par les tableaux d\u00e9sign\u00e9s pae sLgn (pour les lignes) et\n\/\/ sCol (pour les colonnes). La recherche consiste \u00e0 produire au plus\n\/\/ nEssais images al\u00e9atoires et s'arr\u00eate lorsqu'une image correcte\n\/\/ est trouv\u00e9e. La valeur de retour est -1 si aucune image correcte n'est \n\/\/ trouv\u00e9e, sinon c'est le nombre d'essais r\u00e9alis\u00e9s.\nint rechercheRandom(char* img, int dim, int* sLgn, int* sCol, long nEssais)\n<\/code><\/pre>\n<p>Elle doit \u00eatre test\u00e9e de mani\u00e8re artisanale par la fonction <code>main<\/code> suivante :<\/p>\n<pre><code class=\"language-C\">int main()\n{\n    int dim = 4;\n    srand(time(NULL));\n    int sLignes[] = {3,3,2,3};\n    int sColonnes[] = {4,1,4,2}; \n    char image[dim*dim];\n    int n = rechercheRandom(image,dim,sLignes,sColonnes,100000);\n    if(n&gt;0)\n    {\n        printf(&quot;Image trouv\u00e9e en %d essais\\n\\n&quot;,n);\n        afficheImage(image, 4);\n    }\n    else\n    {\n        printf(&quot;Image non trouv\u00e9e\\n&quot;);\n    }\n    return 0;\n}\n<\/code><\/pre>\n<p>L&rsquo;initialisation du germe du g\u00e9n\u00e9rateur pseudoal\u00e9atoire bas\u00e9e sur le temps syst\u00e8me permet d&rsquo;obtenir des tirages diff\u00e9rents \u00e0 chaque ex\u00e9cution du programme.<\/p>\n<p>Vous pourrez constater que non seulement le nombre d&rsquo;essais r\u00e9alis\u00e9s avant d&rsquo;obtenir une image correcte varie d&rsquo;une ex\u00e9cution \u00e0 l&rsquo;autre, mais aussi que l&rsquo;image trouv\u00e9e n&rsquo;est pas toujours la m\u00eame.<\/p>\n<h4><a id=\"recherche-par-force-brute\" class=\"anchor\" aria-hidden=\"true\"><span class=\"octicon octicon-link\"><\/span><\/a>Recherche par force brute<\/h4>\n<p>Cette approche consiste \u00e0 produire de mani\u00e8re syst\u00e9matique toutes les images possibles jusqu&rsquo;\u00e0 en trouver une compatible avec la signature donn\u00e9e. Seules les personnes les plus avanc\u00e9es sont invit\u00e9es \u00e0 traiter cette partie.<\/p>\n<p>Une mani\u00e8re de proc\u00e9der, pour des images de dimension 4, consiste \u00e0 r\u00e9aliser un comptage de \\(0\\) \u00e0 \\(2^{16}-1\\) avec un entier de type <code>uint16_t<\/code>. Pour chaque valeur produite, les 16 bits de l&rsquo;entiers sont transpos\u00e9s dans le tableau repr\u00e9sentant l&rsquo;image.\u00ab\u00a0<\/p>\n<hr \/>\n","protected":false},"excerpt":{"rendered":"<p>Par O. Bailleux, Ma\u00eetre de conf\u00e9rences HDR \u00e0 l&rsquo;universit\u00e9 de Bourgogne. Tomographie discr\u00e8te &#8211; partie 1 Ce TP est la premi\u00e8re partie d&rsquo;un travail qui sera men\u00e9 sur plusieurs s\u00e9ances et dont le but est de r\u00e9aliser une application permettant de reconstituer une image \u00e0 partir d&rsquo;une signature repr\u00e9sentant les nombres de pixels actifs sur [&hellip;]<\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"closed","ping_status":"","sticky":false,"template":"","format":"standard","meta":{"_jetpack_memberships_contains_paid_content":false,"footnotes":""},"categories":[2],"tags":[],"class_list":["post-199","post","type-post","status-publish","format-standard","hentry","category-c-et-cpp","entry"],"jetpack_sharing_enabled":true,"jetpack_featured_media_url":"","_links":{"self":[{"href":"https:\/\/9h15.net\/activ\/wp-json\/wp\/v2\/posts\/199","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/9h15.net\/activ\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/9h15.net\/activ\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/9h15.net\/activ\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/9h15.net\/activ\/wp-json\/wp\/v2\/comments?post=199"}],"version-history":[{"count":1,"href":"https:\/\/9h15.net\/activ\/wp-json\/wp\/v2\/posts\/199\/revisions"}],"predecessor-version":[{"id":200,"href":"https:\/\/9h15.net\/activ\/wp-json\/wp\/v2\/posts\/199\/revisions\/200"}],"wp:attachment":[{"href":"https:\/\/9h15.net\/activ\/wp-json\/wp\/v2\/media?parent=199"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/9h15.net\/activ\/wp-json\/wp\/v2\/categories?post=199"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/9h15.net\/activ\/wp-json\/wp\/v2\/tags?post=199"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}