Crunchez vos adresses URL
|
Calculez la conso électrique de votre PC
|
Hébergez vos photos
Page 77 sur 79 PremièrePremière ... 27676970717273747576777879 DernièreDernière
Affichage des résultats 2 281 à 2 310 sur 2361
  1. #2281
    Citation Envoyé par vectra Voir le message
    C'est des noms de méthode ça? Limite, les intrinsics sont plus lisibles...
    C'est une convention de nommage pour certaines méthodes particulières, par ex. les méthodes du genre "__add__" sont les méthodes appelées par les opérateurs. Les méthodes préfixées par "__" sont cachées (mais pas beaucoup). Plus loin dans la liste, tu as toutes les méthodes normales.
    Rien ne me choque moi, je suis un scientifique ! - I. Jones

  2. #2282
    Figure paternelle de substitution Avatar de TiNitro
    Ville
    Capitale eud'chwal
    hmmm je pensais que ce serait une erreur assez commune... en particulier de développeurs qui viennent d'un autre langage ou il n'y a pas d'opérateur d'incrément et qui mélangent deux syntaxes.

  3. #2283
    Salut !

    Dites, c'est quoi vos sources d'information pour la veille techno ?
    Quand on débarque comme ça c'est un peu compliqué de trier. Ah, je fais du python pour le moment.
    Tof : Fuji XT2 + 35 mm f2 + 18-55 mm f2.8 - 4 + un tas de vieux machins avec des bagues et des bidules

  4. #2284
    Pour ma part, surtout:

    - InfoQ pour tout ce qui est un peu annonces officielles (nouvelle techno, version majeure de langages ou frameworks, article d'archi...)
    - Hacker News pour tout le reste (il faut filtrer, la quantité de liens postés chaque jour est énorme)

    Pour des technos spécifiques:

    Java: le Java annotated mensuel de Jetbrains, la newsletter hebdomadaire de Baeldung
    Kotlin: la newsletter Kotlin weekly
    Javascript: la newsletter ES NExt news

    Rien sur le Python pour le moment, mais j'ai prévu de m'y mettre, donc ça va venir.

  5. #2285
    Citation Envoyé par TwinBis Voir le message
    Pour ma part, surtout:

    - InfoQ pour tout ce qui est un peu annonces officielles (nouvelle techno, version majeure de langages ou frameworks, article d'archi...)
    - Hacker News pour tout le reste (il faut filtrer, la quantité de liens postés chaque jour est énorme)

    Pour des technos spécifiques:

    Java: le Java annotated mensuel de Jetbrains, la newsletter hebdomadaire de Baeldung
    Kotlin: la newsletter Kotlin weekly
    Javascript: la newsletter ES NExt news

    Rien sur le Python pour le moment, mais j'ai prévu de m'y mettre, donc ça va venir.
    Merci pour la newletter kotlin, tiens pour le coup.
    Ce qu'il faut savoir, c'est qu'on ment beaucoup aux minmatars, surtout lorsqu'ils posent des questions du style: "t'es sûr que ça vole, ce truc ?" Cooking Momo, le 30/08/09

  6. #2286
    Concernant python, si tu aime les podcasts (anglophones) il y a Talk Python to me.
    Sinon le subreddit python, y a à boire et à manger mais parfois de bons articles sont linkés (j'y passe quelques minutes par jour pour voir si un sujet m'intéresse.) : https://www.reddit.com/r/Python/new/

  7. #2287
    J'ai pris le humble bundle sur le .Net, et en zyeutant le quickGuide, je suis tombé sur un truc que je ne connaissais pas :


  8. #2288
    Ha, le dernier c'est du Kotlin ?
    Ca fait partie des trucs qui 'ont fait dire "mais purée, il est top ce langage ! need !". Kotlin c'est trop bien.

    [edit] Ha ba non c'est pas du Kotlin, mais c'est proche !

  9. #2289
    Citation Envoyé par gros_bidule Voir le message
    Ha, le dernier c'est du Kotlin ?
    Ca fait partie des trucs qui 'ont fait dire "mais purée, il est top ce langage ! need !". Kotlin c'est trop bien.

    [edit] Ha ba non c'est pas du Kotlin, mais c'est proche !
    C'est du C# v6.

  10. #2290
    Yep, Null-Coalescing Operator et Null-Conditional Operator.

    Ça m'a aussi permis de découvrir COALESCE en SQL qui permet d'éviter d'imbriquer les ISNULL.

  11. #2291
    Citation Envoyé par TwinBis Voir le message
    Pour ma part, surtout:

    - InfoQ pour tout ce qui est un peu annonces officielles (nouvelle techno, version majeure de langages ou frameworks, article d'archi...)
    - Hacker News pour tout le reste (il faut filtrer, la quantité de liens postés chaque jour est énorme)

    Pour des technos spécifiques:

    Java: le Java annotated mensuel de Jetbrains, la newsletter hebdomadaire de Baeldung
    Kotlin: la newsletter Kotlin weekly
    Javascript: la newsletter ES NExt news

    Rien sur le Python pour le moment, mais j'ai prévu de m'y mettre, donc ça va venir.
    Citation Envoyé par Nattefrost Voir le message
    Concernant python, si tu aime les podcasts (anglophones) il y a Talk Python to me.
    Sinon le subreddit python, y a à boire et à manger mais parfois de bons articles sont linkés (j'y passe quelques minutes par jour pour voir si un sujet m'intéresse.) : https://www.reddit.com/r/Python/new/
    Merci pour les liens !

    J'avais trouvé podcast.__init__ mais pas celui ci.
    Tof : Fuji XT2 + 35 mm f2 + 18-55 mm f2.8 - 4 + un tas de vieux machins avec des bagues et des bidules

  12. #2292
    Oui les dernières versions de C# on rajouté plein de sucre syntaxique bien sympa.
    J'aurai bien du mal à m'en passer maintenant d'ailleurs.
    Découvrez les Frontières Virtuelles - Mon Portfolio Photo - Utilisateur de Spotify ? Essaye donc ce soft !

  13. #2293
    J'aurais besoin de vos avis.

    Udemy propose en promo pour encore quelques jours une formation "développeur Web" (avec des vidéos) à 11.99 euros au lieu de 199.99 euros.

    Voir le détail ici:
    https://www.udemy.com/formation-deve...de=UDEAFFES419

    Je ne connais rien en développement web, je suis plutôt sur du développement logiciel mais hors "réseau" (bien qu'on ait fait du PL/SQL).

    Est-ce que vous pensez que, relativement à la somme demandée en promo, ça pourrait être intéressant ?
    Baalimologue - Le topic du The Voice of the X-Factor Canard's Got Talent & autres Vocalises.
    Battle.net (Diablo 3) : Fbzn#2658 ----- / ----- / ----- Steam ID

  14. #2294
    La stack dont il est question (HTML, CSS, Javascript, jQuery, Bootstrap, PHP, MySQL, Wordpress...) me fait pas envie (avis personnel).

    Si t'y connais vraiment rien en web tu peux déjà commencer avec des ressources gratuites : les tutoriels officiels de Django, Ruby on Rails ou autres frameworks web.
    A voir aussi si tu souhaite voir "ailleurs "en terme de langages, habituellement tu fais quoi ?

  15. #2295
    Je ne fais "rien" (professionnellement parlant).
    J'ai juste fait un peu de Java, de PL/SQL ... et des années avant du Turbo-Pascal.
    Baalimologue - Le topic du The Voice of the X-Factor Canard's Got Talent & autres Vocalises.
    Battle.net (Diablo 3) : Fbzn#2658 ----- / ----- / ----- Steam ID

  16. #2296
    C'est que mon avis mais si t'es vraiment tout neuf en matière de web tu peux déjà commencer avec des tutos/livres gratuits, ne serais-ce que pour savoir si ça te plaît.

    EDIT : tu peux essayer ça, pour te faire une idée (je ne met pas d'autres langages, je n'ai pas pratiqué, et niveau JavaScript je suis pas du tout à la page... React? Vue? Angular? Good ol' jQuery?)
    - ruby https://www.railstutorial.org/book
    - python https://www.djangoproject.com/start/
    Dernière modification par Nattefrost ; 18/04/2019 à 21h26.

  17. #2297
    Oh, c'est juste histoire de tâter un peu de la chose et d'avoir les bases.
    Baalimologue - Le topic du The Voice of the X-Factor Canard's Got Talent & autres Vocalises.
    Battle.net (Diablo 3) : Fbzn#2658 ----- / ----- / ----- Steam ID

  18. #2298
    Te presse pas Udemy c'est tout le temps en solde. Et quand je dis tout le temps, c'est que je n'ai jamais vu les "vrai" prix appliqués.

    Sinon, JQuery, PHP, etc, c'est assez daté... retour dans les années 2000, tant qu'a faire autant aller sur OpenClassRooms et lire les tutos de l'époque sur le HTML/CSS/PHP.
    Découvrez les Frontières Virtuelles - Mon Portfolio Photo - Utilisateur de Spotify ? Essaye donc ce soft !

  19. #2299
    J'ai acheté quelques trucs sur Udemy pendant une des nombreuses 'offres spéciales' et je ne suis pas convaincu à 100% par le côté vidéo: j'ai souvent l'impression de regarder un cours de fac soporifique.
    Du coup soit je m'ennuie, soit je zap, soit j'essaie de comprendre de l'anglais non natif à 150% de la vitesse normale...Et je fini par lâcher l'affaire au bout d'une douzaine de cours...

    Ca reste intéressant, mais je préfère un livre ou un tuto en ligne pour pouvoir aller à mon rythme.

    Après tu peux te prendre un cours pour une dizaine d'euros pour te faire une idée et tu tomberas peut être sur un très bon cours super intéressant. En plus là c'est en français.
    Le cours ne surfe pas forcément sur la hype du moment, le jquerry c'est has-been et le php c'est tellement 2007, mais pour si c'est pour avoir les bases je trouve ça plutôt bien car ça reste simple et accessible.

    Le cours fait un peu le tour des différents domaines et tu pourras piocher dedans, et voir ce que tu veux approfondir ou ignorer. Pour un usage perso c'est peut être un bon pack.
    Perso je conseillerais plutôt le même genre de pack avec python comme langage serveur, voir le pack avec nodejs pour rester avec un seul langage du début à la fin.

  20. #2300
    Bon, je crois que je vais passer mon tour alors.

    Merci pour vos avis.
    Baalimologue - Le topic du The Voice of the X-Factor Canard's Got Talent & autres Vocalises.
    Battle.net (Diablo 3) : Fbzn#2658 ----- / ----- / ----- Steam ID

  21. #2301
    Vous vous souvenez que j'étais épaté par les capacités des compilos à anticiper le résultat de fonctions impliquant des calculs avec des boucles ?
    J'ai trouvé récemment un billet de blog qui explique le principe d'analyse des boucles pour effectuer ce genre d'anticipation : https://kristerw.blogspot.com/2019/0...tric-sums.html
    Rien ne me choque moi, je suis un scientifique ! - I. Jones

  22. #2302
    Attention pavé.

    Ca fait quelques temps que je bute sur des histoires de filtres codés en templates C++ d'un côté, et impératifs de dispatch dynamique de l'autre. Typiquement, pour un programme qui lit un fichier d'image de type variable, et de fait uniquement connu à l'exécution, bien qu'appartenant à une liste bien délimitée.

    Récemment, j'ai trouvé SITK, un wrapper C++ et/ou python qui permet d'utiliser ITK sans avoir à expliciter tous les types et dimensions à manipuler comme des paramètres template. Pour mon taf, je dois l'utiliser et c'est pas mal compte-tenu du très grand nombre de filtres ITK immédiatement accessibles avec une syntaxe minimaliste (celle de python, rien de plus). Fin de l'apparté sur SITK, je vous expose mon souci.

    J'ai un programme simple qui lit une image (volume 3D) passée en argument et affiche une image SITK en troisdé avec un slicer. On peut consulter la taille de l'image allouée et le type de données allouée (enum class du genre sitk::sitkFloat64 pour double). Je veux effectuer un traitement avec un filtre custom qui soit le plus simple possible. Pour gérer la multiplicité de types possibles à gérer pour le volume, et éventuellement les arguments du filtre, j'ai opté pour écrire une fonction template.

    Voici le code que j'obtiens du côté du programme principal:

    Code:
    int
    main(int argc, char *argv[])
    {
      progArgs args; // structure unique où on range les arguments du prog.
      usage(argc, argv, args);
    
      sitk::Image imgRead;
      imgRead = sitk_util::sitk_read_series(args . input_volume_path); // fonction à moi qui lit des images 3D DICOM
      cout << endl << << imgRead.GetPixelIDTypeAsString();  // 64-bit float, 32-bit float, etc selon fichier lu
    
      ExecutorSITK exe_filter;
      exe_filter . execute_dispatch(imgRead, {"-32768", "0"}); // remplace les occurences erratiques de "-32768" par la valeur "0"
    
      sitk_util::showme_blocking_function(imgRead, "image apres lecture et filtrage viteuf");
      return EXIT_SUCCESS;
    }
    Voici la classe ExecutorSITK dans laquelle on définit le filtre personnalisé. C'est en gros la partie publique du mécanisme, celle où l'utilisateur écrit son filtre sans limite de typage ni contraintes de signature, et doit juste écrire une fonction qui dispatche les arguments du filtre à partir d'un vecteur de strings.

    Code:
    /*!
     * @class ExecutorSITK
     * @brief user-created class for dispatching a user template filter on a SITK instance
     */
    class ExecutorSITK : public motherVolume
    {
     public:
      ExecutorSITK() = default;
      
      /*!
       * @brief replaces all voxel occurences of a value by another for any numeric type T
       * @tparam T : instance of numerical C-type handled by SITK, compile error if not scalar
       * @param src_value : value to replace
       * @param target_value : target value
       * @return void
       */
      template < typename T >
      std::enable_if<std::is_scalar<T>::value, void>
      filter_function(T src_value, T target_value)
      {
        T *data = static_cast<T *>(motherVolume::data_ptr);
        
        for (size_t i = 0; i < motherVolume::nb_voxels; i ++)
          {
            if ( data[i] == src_value )
              data[i] = target_value;
          }
      }
     
     
     protected:
      
      /*!
       * @brief user-defined function dispatching string arguments to the user-defined filter above
       * @tparam T
       * @param img
       * @param args : vector of strings containing arguments to dispatch
       */
      template < typename T >
      void filter_execute_typed(sitk::Image &img, std::vector<string> args)
      {
        T a = boost::lexical_cast<T>(args[0]);
        T b = boost::lexical_cast<T>(args[1]);
        filter_function<T>(a, b);
      }
      
      
      // macro-call linking the filter to the override system
      OVERRIDE_INVOKE(filter_execute_typed)
    };
    La macro s'expande comme suit:
    Code:
    /*
    void override_execute_double(sitk::Image &img, std::vector<string> args)
    {
      filter_execute_typed<double>(img, args);
    }
    
    void override_execute_float(sitk::Image &img, std::vector<string> args)
    {
      filter_execute_typed<float>(img, args);
    }
    
    void override_execute_int(sitk::Image &img, std::vector<string> args)
    {
      filter_execute_typed<int>(img, args);
    }
    */
    Et enfin, voilà la classe de base qui permet de faire fonctionner le mécanisme. L'idée est de pousser le plus de choses possible dans elle afin que l'utilisateur n'ait presque rien à faire en définissant ses classes dérivées pour gérer les filtres qu'il écrit:

    Code:
    class motherVolume
    {
     protected:
      size_t x_dim, y_dim, z_dim;
      double x_size, y_size, z_size;
      
      void   *data_ptr;
      size_t nb_voxels;
      
     
     public:
      motherVolume()
      {}
     
     protected:
      void set_volume(sitk::Image &img)
      {
        data_ptr                   = sitk_util::get_ptr_from_sitk(img); // extrait le pointeur void* du volume sitk
        nb_voxels                = img . GetNumberOfPixels();
        vector<unsigned int> v_dim = img . GetSize();
        x_dim = v_dim[0];
        y_dim = v_dim[1];
        z_dim = v_dim[2];
        // TODO size
      }
      
      virtual void override_execute_double(sitk::Image &img, std::vector<string> args)
      {
        MSG_ERROR("nope double");
      }
      virtual void override_execute_float(sitk::Image &img, std::vector<string> args)
      {
        MSG_ERROR("nope float");
      }
      virtual void override_execute_int(sitk::Image &img, std::vector<string> args)
      {
        MSG_ERROR("nope int");
      }
     
     public:
      void execute_dispatch(sitk::Image &img, std::vector<string> args)
      {
        motherVolume::set_volume(img);
        
        switch (img . GetPixelID())
          {
            case sitk::sitkFloat64:
              {
                override_execute_double(img, args);
                break;
              }
            case sitk::sitkFloat32:
              {
                override_execute_float(img, args);
                break;
              }
            case sitk::sitkInt32:
              {
                override_execute_int(img, args);
                break;
              }
            default:
            MSG_ERROR("yet unhandled type");
          }
      }
      
    };
    La bonne nouvelle, c'est que c'est du vrai code qui fonctionne, et ce après diverses versions toutes plus foirées les unes que les autres.
    Je pense que je ne suis pas loin d'avoir atteint mes limites dans la compréhension du langage : si vous avez des idées pour templatizer ça mieux, je suis prendeur.
    Et oui, il y a de la redondance de l'instance de l'image sitk dans les différentes classes et signatures de fonction; mais c'est pas encore trop grave vu que c'est un smart pointer à la base (je l'ai fixé dans une autre version)

    Voilà, n'hésitez pas à tout défoncer; c'est fait pour ça
    Dernière modification par vectra ; 03/05/2019 à 17h48.

  23. #2303
    Citation Envoyé par vectra Voir le message
    Voilà, n'hésitez pas à tout défoncer; c'est fait pour ça
    Question bête en passant, pourquoi ne pas conserver en mémoire uniquement des double, et faire la conversion du type au chargement et sauvegarde du fichier ?
    Reality is that which, when you stop believing in it, doesn't go away. (Philip K. Dick)

  24. #2304
    Sur le fond, le double prend le plus de place en mémoire (64 bits) et est le plus long à traiter (se vectorise moins selon la taille en bits justement).
    C'est rare qu'on ait des double d'ailleurs; même le float 32 bits est ponctuel. Si tu prends des volumes assez grands, ou des traitements assez gourmands, tu vas constater un gouffre en temps de traitement selon le type de données.
    On a aussi des types signés et non signés à charger; or le double est nécessairement signé là où, spécifiquement, on veut pas de négatifs.

    Sur l'interface, j'aimerais m'assurer que certains paramètres du filtre sont exactement du même type que la donnée (e.g seuils) et d'autres non (e.g nombre d'itérations, taille de fenêtre).

    Enfin, surtout, je pense que j'ai manqué certains mécanismes template dans ma n'alyze, en particuliers ceux qui ont pu être introduits avec C++11, 14 et 17.

  25. #2305
    Qu'est ce qui changerait entre différents filtres dans les implémentations des override_execute_* ou dans celle de filter_execute_typed (en dehors du nombre d'argument) ? Est ce que la boucle dans filter_function pourrait être différente ?

    En gros est ce qu'on pourrait pas réduire le filtre à un simple lambda/functor surchargé du genre [](auto &data, auto src_value, auto target_value) { if ( data == src_value ) data = target_value; } ?

    Edit:
    Ça permet d'écrire des trucs de ce genre : https://gcc.godbolt.org/z/pRxsN6

    C'est du C++17 pour le apply et le tuple sans paramètre, ça doit être possible en C++14 avec un peu plus d'effort.

    Si je lis l'assembleur correctement, la boucle semble bien être inliné, donc ça devrait être bon pour les performances.

    Edit2:
    En fait on peut retirer le besoin d'apply en utilisant un bind
    Code:
    template<typename T, typename Filter, typename... Args>
    void execute_filter(Image &img, Filter &&filter, Args &&... args)
    {
        using namespace std::placeholders;
        auto filter_with_args = std::bind(std::forward<Filter>(filter), _1, boost::lexical_cast<T>(std::forward<Args>(args))...);
        auto data = static_cast<T *>(img.data);
        for (int i = 0; i < img.count; ++i)
            filter_with_args(data[i]);
    }
    Donc seulement C++14 requis pour les lambdas auto, voire C++11 si tu utilises un functor à la place du lambda (https://gcc.godbolt.org/z/NBUgm1).
    Dernière modification par Cwningen ; 04/05/2019 à 16h53.

  26. #2306
    Le besoin de base, c'est de dispatcher une fonction arbitraire avec un type numérique template et de lui faire mouliner un volume dont le type n'est connu qu'à l'exécution parmi une liste restrictive (il y en a une dizaine en tout, j'en ai seulement mis 3 par clarté).

    Alors a priori j'ai quartier libre pour la version du C++
    Le filtre est supposé être 100% arbitraire dans la signature comme dans la complexité, y compris par exemple des fonctions ITK ou autres qui ne figurent pas dans la partie recouverte par SITK. Pour tout le reste, je suis ouvert à toute solution sans restriction: la machinerie que j'ai mise en place, c'est juste la solution la moins pire à laquelle j'ai pensé, et on peut tout jeter pour mieux car ce n'est pas encore déployé.


    Je ne savais même pas qu'il y avait des lambda auto :j'ai beau me remettre sérieusement au C++, je me sens quand-même un peu largué là.

    Merci *beaucoup* pour ces éléments, je vais déjà essayer de voir Lundi comment ça fonctionne et ce que je peux faire avec. J'ai besoin d'une bonne update mais je suis en déplacement pour ce WE
    Dernière modification par vectra ; 04/05/2019 à 19h59.

  27. #2307
    Bon, j'ai lu ta solution avec mon éditeur habituel, et je comprends maintenant ta question.

    J'ai besoin de pouvoir coder toute la boucle moi-même, et je ne peux en général pas me contenter de passer le corps de la boucle par une lambda auto. Mais vu que j'ignorais qu'on pouvait le faire, ça m'est très utile de toute manière, et j'aurais l'occasion de le faire quand ça va bien!
    Typiquement, je vais avoir des boucles déjà écrites à intégrer, et par exemple, je vais vouloir coller du pragma omp en tête de certaines boucles que j'écrirai moi-même. Mon SSE est un peu rouillé, mais je crois que je vais devoir adapter le pas de parcours à la taille du vecteur.

    Une chose aussi dont j'aurais besoin, c'est de spécialiser la fonction du filtre selon le type template. Par exemple, me contenter d'une version générique (typename T) dans le cas général tout en tirant parti d'une implémentation particulière (e.g, si je prends la peine d'écrire une version SSE pour float). J'ai essayé avec ma version va-nu-pieds, et elle l'accepte.

    Je vois des éléments très intéressants dans ce que tu me donnes, et qui comblent en partie mon incultance. La récupération par un tuple des arguments du template variadique, ça me fait un peu rêver (lisp is back ). J'aimerais bien que ça puisse aider à supprimer du code sale dans ce que j'ai écrit. Mais par contre, il est important que je puisse spécifier des types autres que T, comme par exemple du size_t pour une taille de fenêtre, etc... D'après ce que je vois dans l'exemple fourni là-dessous, je ne sais pas si ça va coller par contre:
    https://en.cppreference.com/w/cpp/utility/apply

  28. #2308
    Je suis en train de jouer avec une évolution de la version précédente qui utilise basiquement les templates variadiques.
    Y'a encore du boulot:

    https://gcc.godbolt.org/z/YIZQ-3

    Le problème de cette approche, outre des répétitions pas encore factorisées, c'est que je ne peux plus décider qu'un ou plusieurs des paramètres de la fonction soit du même type que le type de données du volume, qui lui est connu à l'exécution seulement...

    Code:
    ExecutorSITK2<double, float, std::string> toto;
    toto.execute_dispatch(imgRead, double(-32768), double(0), "hi there");

  29. #2309
    Citation Envoyé par vectra Voir le message
    J'ai besoin de pouvoir coder toute la boucle moi-même, et je ne peux en général pas me contenter de passer le corps de la boucle par une lambda auto. Mais vu que j'ignorais qu'on pouvait le faire, ça m'est très utile de toute manière, et j'aurais l'occasion de le faire quand ça va bien!
    Typiquement, je vais avoir des boucles déjà écrites à intégrer, et par exemple, je vais vouloir coller du pragma omp en tête de certaines boucles que j'écrirai moi-même. Mon SSE est un peu rouillé, mais je crois que je vais devoir adapter le pas de parcours à la taille du vecteur.
    Tu peux bouger la boucle dans le filtre, ce n'est pas un problème. Ça doit même simplifier puisque les résultats des lexical_cast sont stocké dans les paramètres de la fonction (donc plus besoin du tuple ou du bind).

    Citation Envoyé par vectra Voir le message
    Une chose aussi dont j'aurais besoin, c'est de spécialiser la fonction du filtre selon le type template. Par exemple, me contenter d'une version générique (typename T) dans le cas général tout en tirant parti d'une implémentation particulière (e.g, si je prends la peine d'écrire une version SSE pour float). J'ai essayé avec ma version va-nu-pieds, et elle l'accepte.
    Ça devrait marcher aussi dans mon cas. N'oublie pas que les lambdas ne sont que du sucre syntaxique.
    Code:
    auto fonction = [](auto a, auto b) { /* ... */ }
    est plus ou moins équivalent à
    Code:
    struct {
        template<typename T1, typename T2>
        auto operator()(T1 a, T2 b) const {
            /* ... */
        }
    } fonction;
    Les fonctions qui prennent le filtre sont génériques, ça marche pareil que ce soient des lambdas, des functors, des objets retournés par bind ou n'importe quel objet appelable.

    Tu devrais aussi jeter un coup d'œil à l'opérateur overloaded utilisé dans l'exemple de std::visit (ce n'est malheureusement pas dans la bibliothèque standard mais ça prend deux lignes à définir). C'est pratique pour rassembler plusieurs lambdas en un seul objet.

    Citation Envoyé par vectra Voir le message
    Mais par contre, il est important que je puisse spécifier des types autres que T, comme par exemple du size_t pour une taille de fenêtre, etc... D'après ce que je vois dans l'exemple fourni là-dessous, je ne sais pas si ça va coller par contre:
    https://en.cppreference.com/w/cpp/utility/apply
    Deux idées me viennent.

    1) Si le type ne dépend pas de T et est fixe, tu peux passer la valeur au constructeur du filtre ou en capture du lambda.

    2) Si tu as vraiment besoin d'ajouter un fonction de conversion spéciale pour chaque filtre, tu peux appeler directement ExecutorSITK::filter_execute_typed depuis motherVolume::execute_dispatch et donc te passer des override_execute_* et de la macro, si motherVolume ou execute_dispatch connait le type de la classe dérivée. Le CRTP est une solution pour ça.

    Par exemple:

    Code:
    template<typename Derived>
    class motherVolume
    {
    public:
      void execute_dispatch(sitk::Image &img, std::vector<string> args)
      {
        motherVolume::set_volume(img);
        
        switch (img . GetPixelID())
          {
            case sitk::sitkFloat64:
              {
                static_cast<Derived *>(this)->filter_execute_typed<double>(img, args);
                break;
              }
            case sitk::sitkFloat32:
              {
                static_cast<Derived *>(this)->filter_execute_typed<float>(img, args);
                break;
              }
            case sitk::sitkInt32:
              {
                static_cast<Derived *>(this)->filter_execute_typed<int>(img, args);
                break;
              }
            default:
            MSG_ERROR("yet unhandled type");
          }
      }
    };
    
    class ExecutorSITK : public motherVolume<ExecutorSITK>
    {
     public:
      
      template < typename T >
      std::enable_if<std::is_scalar<T>::value, void>
      filter_function(T src_value, T target_value)
      {
        T *data = static_cast<T *>(motherVolume::data_ptr);
        
        for (size_t i = 0; i < motherVolume::nb_voxels; i ++)
          {
            if ( data[i] == src_value )
              data[i] = target_value;
          }
      }
      
      template < typename T >
      void filter_execute_typed(sitk::Image &img, std::vector<string> args)
      {
        T a = boost::lexical_cast<T>(args[0]);
        T b = boost::lexical_cast<T>(args[1]);
        filter_function<T>(a, b);
      }
    };
    Chaque filtre a une base spécialisé différente, mais je n'ai pas l'impression que tu avais besoin d'une base commune à tous, donc ça pourrait convenir.

  30. #2310
    Je suis en train de jouer avec une évolution de la version précédente qui utilise basiquement les templates variadiques.
    Y'a encore du boulot:

    https://gcc.godbolt.org/z/YIZQ-3

    Le problème de cette approche, outre des répétitions pas encore factorisées, c'est que je ne peux plus décider qu'un des paramètres de la fonction sera du même type que le type de données du volume, qui lui est connu à l'exécution seulement.

    Je vois qu'il y a du cross-posting de fou
    Je vais voir ça au calme à la maison...
    La définition récursive du CRTP ... mais je n'arrive pas à la faire marcher hélas
    Dernière modification par vectra ; 06/05/2019 à 18h57.

Règles de messages

  • Vous ne pouvez pas créer de nouvelles discussions
  • Vous ne pouvez pas envoyer des réponses
  • Vous ne pouvez pas envoyer des pièces jointes
  • Vous ne pouvez pas modifier vos messages
  •