User Tools

Site Tools

Trace:
cpp:ps

Differences

This shows you the differences between two versions of the page.

Link to this comparison view

Next revision		Previous revision
cpp:ps [2022/06/22 12:01] – créée francoiscpp:ps [2022/12/09 09:39] (current) – charles
Line 1: Line 1:
 ====== Exemple Pattern Spectra ====== ====== Exemple Pattern Spectra ======
  
-Dans cet exemple, nous allons réaliser un programme qui produit des fichiers HDF5 (binaire structuré) contenant des tableau à 2 dimension de pattern spectra.+Dans cet exemple, nous allons réaliser un programme qui produit des fichiers HDF5 (binaire structuré) contenant des tableaux à 2 dimensions de pattern spectra. 
 +Le programme prend 2 arguments : 
 +  * le nom du fichier contenant l'image en entrée qui construira un arbre MAX et des attributs 
 +  * le nom du fichier qui les données produites (principalement un pattern spectra)
  
 +Dans cet exemple nous proposons de réaliser un pattern spectra à 2 dimensions. Cela signifie que la contribution de chaque nœud sera cumulé en fonction
 +  * de la taille du nœud
 +  * et de sa caractéristique d'être compact ou non
 +
 +===== Visualisation =====
 +
 +Nous avons utilisé un script python pour visualiser le tableau à 2 dimensions.
 +Nous avons joué avec les paramètres pour disposer d'axes linéaires ou logarithmiques.
  
 ^ ^  linear  ^  log  ^ ^ ^  linear  ^  log  ^
Line 8: Line 19:
 ^  log  ^ {{ :cpp:arlesft.png?nolink&200 |}} | {{ :cpp:arlesff.png?nolink&200 |}} | ^  log  ^ {{ :cpp:arlesft.png?nolink&200 |}} | {{ :cpp:arlesff.png?nolink&200 |}} |
  
 +===== Code =====
 +
 +Il faut commencer par les déclarations d'usage. La première pour réaliser des traces lors de l'exécution (le calcul du périmètre et un peu lent). Les autres sont là pour rappel.
 <code c++> <code c++>
 #include <iostream> #include <iostream>
Line 25: Line 39:
 </code> </code>
  
 +Nous aurons besoin des quelques classes fondamentales : la structure d'arbre, le poids des nœuds et un ensembles d'autres attributs pour le pattern spectra.
 <code c++> <code c++>
 #include "ArrayTree/ArrayTreeBuilder.hpp" #include "ArrayTree/ArrayTreeBuilder.hpp"
Line 33: Line 48:
 </code> </code>
  
 +En fonction de ce qui a été déclaré, il peut être utile de simplifier les appels en omettant le contexte d'utilisation (par exemple en évitant de préfixer avec ''std::''). 
 <code c++> <code c++>
 using namespace std; using namespace std;
Line 40: Line 56:
 </code> </code>
  
 +Dans notre exemple, nous nous limiterons à des images 2D et la construction d'un arbre MAX.
 +Nous préfererons un histogramme logarithmique par défaut.
 +Nous choisissons un pattern spectra de 900 casses (30 bin x 30 bin).
 +La compression HDF5 a besoin de paramètres propres (taux de compression, taille de cache).
 <code c++> <code c++>
-inline unsigned int abs (unsigned int x) { return x;} 
- 
 typedef uint16_t DimBin; typedef uint16_t DimBin;
  
 static const int GeoDimT (2); static const int GeoDimT (2);
-static TreeType treeType = MAX; +static const TreeType treeType = MAX; 
-static DimBin linearCompactBin (false), linearAreaBin (false); +static const DimBin linearCompactBin (false), linearAreaBin (false); 
-static DimBin binCompactCount (30), binAreaCount (30); +static const DimBin binCompactCount (30), binAreaCount (30); 
-static unsigned int compressLevel (5); +static const unsigned int compressLevel (5); 
-static size_t cacheSize (1024*1024);+static const size_t cacheSize (1024*1024);
 </code> </code>
  
 +Nous déclarons la fonction ''patternSpectra'' qui réalisera le calcul et l'écriture du résultat. Elle sera donc dépendante de la nature des pixels lus InPixelT, de l'image en entrée et du nom de fichier à produire. 
 <code c++> <code c++>
 template<typename PixelT> void patternSpectra (const IImage<GeoDimT> &inputImage, const string &outputData); template<typename PixelT> void patternSpectra (const IImage<GeoDimT> &inputImage, const string &outputData);
 </code> </code>
 +
 +Nous définissons une fonction créant des intervalles (au nombre de ''binCount'') de valeurs logarithmiques entre un minimum et un maximum.
  
 <code c++> <code c++>
Line 70: Line 91:
 </code> </code>
  
 +Nous définissons une fonction créant des intervalles (au nombre de ''binCount'') de valeurs de même taille entre un minimum et un maximum.
 <code c++> <code c++>
 /** Create linear bin */ /** Create linear bin */
Line 82: Line 104:
 </code> </code>
  
 +Le point d'entrée du programme commencera par analyser les arguments :
 +
 +  * argv[0] : nom du programme
 +  * argv[1] : nom du fichier contenant l'image en entrée
 +  * argv[2] : nom du fichier contenant les données produites
 <code c++> <code c++>
 int int
Line 94: Line 121:
 </code> </code>
  
 +En fonction des pixels de l'image nous invoquerons la fonction ''patternSpectra'' avec le bon type. 
 <code c++> <code c++>
   switch (inputImage.getDataType ()) {   switch (inputImage.getDataType ()) {
Line 119: Line 147:
 </code> </code>
  
 +Voici la fonction principale du programme. 
 +Elle commence par lire les pixels.
 <code c++> <code c++>
 template<typename PixelT> template<typename PixelT>
Line 128: Line 158:
   Raster<PixelT, GeoDimT> raster;   Raster<PixelT, GeoDimT> raster;
   // image size (width x height)   // image size (width x height)
-  Size<GeoDimT> size (inputImage.getSize ());+  const Size<GeoDimT> size (inputImage.getSize ());
   // read first band (0) in 2D mode from origine [0,0] to end [width, height].   // read first band (0) in 2D mode from origine [0,0] to end [width, height].
   inputImage.readBand (raster, 0, NullPoint2D, size);   inputImage.readBand (raster, 0, NullPoint2D, size);
 </code> </code>
  
 +Nous déclarons l'objet arbre qui contiendra le chaînage des feuilles vers la racine. 
 <code c++> <code c++>
   cout << "Build tree" << endl;   cout << "Build tree" << endl;
   // no border (i.e. all pixels are take in account)   // no border (i.e. all pixels are take in account)
-  Border<GeoDimT> border (size, false);+  const Border<GeoDimT> border (size, false);
   // neighbors take in account (default connectivity C4)   // neighbors take in account (default connectivity C4)
-  GraphWalker<GeoDimT> graphWalker (border);+  const GraphWalker<GeoDimT> graphWalker (border);
   // tree builder base on raster, connectivity and type of tree   // tree builder base on raster, connectivity and type of tree
   ArrayTreeBuilder<PixelT, PixelT, GeoDimT> atb (raster, graphWalker, treeType);   ArrayTreeBuilder<PixelT, PixelT, GeoDimT> atb (raster, graphWalker, treeType);
Line 149: Line 180:
 </code> </code>
  
 +Nous déclenchons la construction de l'arbre.
 +  * ATB contient les éléments de l'images (matrice de pixels, connectivité, type d'arbre)
 +  * tree coquille vide qui va contenir l'arbre
 +  * weightAttributes est le premier tableau d'attributs associés aux nœuds (niveaux de gris)
 <code c++> <code c++>
   atb.buildTree (tree, weightAttributes);   atb.buildTree (tree, weightAttributes);
 </code> </code>
  
 +Nous créons autant de tableau d'attributs associés aux nœuds que nécessaire (taille en pixels, périmètre, propriété d'être compact).
 <code c++> <code c++>
   // create area attribute   // create area attribute
   cout << "Build Area Attributes" << endl;   cout << "Build Area Attributes" << endl;
-  AreaAttributes<GeoDimT> areaAttributes (tree);+  const AreaAttributes<GeoDimT> areaAttributes (tree);
   cout << "Build Perimeter Attributes" << endl;   cout << "Build Perimeter Attributes" << endl;
-  PerimeterAttributes<GeoDimT> perimeterAttributes (tree, graphWalker);+  const PerimeterAttributes<GeoDimT> perimeterAttributes (tree, graphWalker);
   cout << "Build Compactness Attributes" << endl;   cout << "Build Compactness Attributes" << endl;
-  CompactnessAttributes<GeoDimT> compactnessAttributes (tree, areaAttributes, perimeterAttributes);+  const CompactnessAttributes<GeoDimT> compactnessAttributes (tree, areaAttributes, perimeterAttributes);
 </code> </code>
  
 +Nous construisons des intervalles de valeurs (abscisses et ordonnées).
 <code c++> <code c++>
   cout << "Build PS" << endl;   cout << "Build PS" << endl;
-  static DimImg MaxArea (size.getPixelsCount ()); +  const DimImg MaxArea (size.getPixelsCount ()); 
-  vector<double> compactScale = linearCompactBin ?+  const vector<double> compactScale = linearCompactBin ?
     linearSpace (0., 1., binCompactCount) :     linearSpace (0., 1., binCompactCount) :
     logSpace (1./MaxArea, 1., binCompactCount);     logSpace (1./MaxArea, 1., binCompactCount);
-  vector<double> areaScale = linearAreaBin ?+  const vector<double> areaScale = linearAreaBin ?
     linearSpace (1., MaxArea, binAreaCount) :     linearSpace (1., MaxArea, binAreaCount) :
     logSpace (1, MaxArea, binAreaCount);     logSpace (1, MaxArea, binAreaCount);
 </code> </code>
  
 +Nous calculons le pattern spectra en parcourant tous les nœuds.
 <code c++> <code c++>
   vector<double> psTab (binAreaCount * binCompactCount, 0.);   vector<double> psTab (binAreaCount * binCompactCount, 0.);
Line 182: Line 220:
  
   for (DimParent compId = 0; compId < rootId; ++compId) {   for (DimParent compId = 0; compId < rootId; ++compId) {
-    DimBin areaBinId = lower_bound (areaScale.begin (), areaScale.end (), double (areaValues[compId])) - areaScale.begin (); +    const DimBin areaBinId = lower_bound (areaScale.begin (), areaScale.end (), double (areaValues[compId])) - areaScale.begin (); 
-    DimBin compactBinId = lower_bound (compactScale.begin (), compactScale.end (), double (compactValues[compId])) - compactScale.begin (); +    const DimBin compactBinId = lower_bound (compactScale.begin (), compactScale.end (), double (compactValues[compId])) - compactScale.begin (); 
-    double diff = abs (double (weightValues[compId])- +    const double diff = abs (double (weightValues[compId]) - 
-        double (weightValues[tree.getCompParent (compId)])); +      double (weightValues[tree.getCompParent (compId)])); 
-    double volume = diff * areaValues[compId];+    const double volume = diff * areaValues[compId];
  
-    size_t id (compactBinId + areaBinId * binCompactCount);+    const size_t id (compactBinId + areaBinId * binCompactCount);
     psTab [id] += volume;     psTab [id] += volume;
   }   }
 </code> </code>
  
 +Nous construisons, pour l'exemple, une représentation réduite du pattern spectra (de nombreuses cases sont vides).
 <code c++> <code c++>
   vector<DimBin> reduceBinIdx;   vector<DimBin> reduceBinIdx;
Line 204: Line 243:
 </code> </code>
  
 +Nous sauvons les valeurs dans un fichier HDF5.
 <code c++> <code c++>
   cout << "Write HDF5" << endl;   cout << "Write HDF5" << endl;
Line 221: Line 261:
 </code> </code>
  
 +===== Résultat =====
 +
 +La commande ''h5ls'' permet de visualiser la structure du fichier
 +  * PS : Tableau à 2 dimension contenant le Pattern Spectra (''30*30 = 900'')
 +  * XLabel, XTick : Nom de l'axe des abscisses et des intervalles choisis
 +  * YLabel, Ytick : Nom de l'axe des abscisses et des intervalles choisis
 +  * patchPSBinIdx, patchPSBinVal : représentation réduite du tableau (seuls les cases avec une valeur sont enregistré avec leur index).
 +<code bash>
 +$ h5ls arles.kor 
 +PS                       Dataset {900}
 +XLabel                   Dataset {SCALAR}
 +XTick                    Dataset {30}
 +YLabel                   Dataset {SCALAR}
 +Ytick                    Dataset {30}
 +patchPSBinIdx            Dataset {69}
 +patchPSBinVal            Dataset {69}
 +</code>
 +
 +La commande ''h5dump'' permet d'afficher les valeurs contenues dans le fichier.
 +<code bash>
 +$ h5dump arles.kor 
 +HDF5 "arles.kor" {
 +GROUP "/" {
 +</code>
 +
 +Le Pattern Spectra est constitué de 30 x 30 cases.
 +<code bash>
 +   DATASET "PS" {
 +      DATATYPE  H5T_IEEE_F64LE
 +      DATASPACE  SIMPLE { ( 900 ) / ( 900 ) }
 +      DATA {
 +      (0): 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
 +... 
 +      (883): 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
 +      }
 +   }
 +</code>
 +
 +Voici les information permettant de reconstituer l'axe des abscisses.
 +<code bash>
 +   DATASET "XLabel" {
 +      DATATYPE  H5T_STRING {
 +         STRSIZE 12;
 +         STRPAD H5T_STR_NULLTERM;
 +         CSET H5T_CSET_ASCII;
 +         CTYPE H5T_C_S1;
 +      }
 +      DATASPACE  SCALAR
 +      DATA {
 +      (0): "Compactness"
 +      }
 +   }
 +   DATASET "XTick" {
 +      DATATYPE  H5T_IEEE_F64LE
 +      DATASPACE  SIMPLE { ( 30 ) / ( 30 ) }
 +      DATA {
 +      (0): 0, 0.0344828, 0.0689655, 0.103448, 0.137931, 0.172414, 0.206897,
 +... 
 +      (25): 0.862069, 0.896552, 0.931034, 0.965517, 1
 +      }
 +   }
 +</code>
 +
 +Voici les information permettant de reconstituer l'axe des ordonnées.
 +<code bash>
 +   DATASET "YLabel" {
 +      DATATYPE  H5T_STRING {
 +         STRSIZE 5;
 +         STRPAD H5T_STR_NULLTERM;
 +         CSET H5T_CSET_ASCII;
 +         CTYPE H5T_C_S1;
 +      }
 +      DATASPACE  SCALAR
 +      DATA {
 +      (0): "Area"
 +      }
 +   }
 +   DATASET "Ytick" {
 +      DATATYPE  H5T_IEEE_F64LE
 +      DATASPACE  SIMPLE { ( 30 ) / ( 30 ) }
 +      DATA {
 +      (0): 1, 1.75326, 3.07394, 5.38942, 9.44908, 16.5667, 29.0459, 50.9251,
 +... 
 +      (28): 6.72556e+06, 1.17917e+07
 +      }
 +   }
 +</code>
 +
 +Pour l'exemple voici une autre représentation (réduite) du Parttern Spectra.
 +<code bash>
 +
 +   DATASET "patchPSBinIdx" {
 +      DATATYPE  H5T_STD_U16LE
 +      DATASPACE  SIMPLE { ( 69 ) / ( 69 ) }
 +      DATA {
 +      (0): 70, 75, 96, 98, 100, 124, 125, 126, 127, 152, 153, 154, 155, 156,
 +... 
 +      (66): 841, 871, 872
 +      }
 +   }
 +   DATASET "patchPSBinVal" {
 +      DATATYPE  H5T_IEEE_F64LE
 +      DATASPACE  SIMPLE { ( 69 ) / ( 69 ) }
 +      DATA {
 +      (0): 6.7979e+06, 7.63336e+06, 6.20837e+06, 7.33739e+06, 125310,
 +... 
 +      (66): 3.50345e+09, 2.9508e+09, 1.09653e+09
 +      }
 +   }
 +}
 +}
 +</code>
cpp/ps.1655899317.txt.gz · Last modified: by francois

Page Tools

Donate Powered by PHP Valid HTML5 Valid CSS Driven by DokuWiki