gui/src/loader.cpp at 508f743bcb108f7559ab278d6d7dd3c0bc210528 · arbor-sim/gui · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
#include <vector>
#include <string>
#include <filesystem>

#include <arborio/neurolucida.hpp>
#include <arborio/neuroml.hpp>
#include <arborio/swcio.hpp>
#include <arbor/morph/morphology.hpp>

#include "loader.hpp"

namespace io {

loaded_morphology load_swc(const std::filesystem::path &fn,
                           std::function<arb::morphology(const std::vector<arborio::swc_record> &)> swc_to_morph) {

    return { swc_to_morph(arborio::parse_swc(slurp(fn)).records()),
             {{"soma",   "(tag 1)"},
              {"axon",   "(tag 2)"},
              {"dend",   "(tag 3)"},
              {"apic",   "(tag 4)"}},
             {}};
}

loaded_morphology load_neuron_swc(const std::filesystem::path &fn) {
    arborio::swc_loader_options opts;
    auto loaded = arborio::load_swc_neuron(fn, opts);
    loaded_morphology res{.morph=loaded.morphology};
    for (const auto& [k, v]: loaded.labels.regions()) res.regions.emplace_back(k, to_string(v));
    for (const auto& [k, v]: loaded.labels.locsets()) res.locsets.emplace_back(k, to_string(v));
    log_info("Loaded SWC (Neuron) {} branches {} ", loaded.segment_tree.size(), loaded.morphology.num_branches());
    return res;
}

loaded_morphology load_cnic_swc(const std::filesystem::path &fn) {
    arborio::swc_loader_options opts {.allow_non_monotonic_ids=true,
                                      .allow_mismatched_tags=true,
                                      .tags={{0, "undefined"},
                                             {1, "soma"}, {2, "axon"}, {3, "dend"}, {4, "apic"},
                                             {5, "fork point"},
                                             {6, "end point"}}
   };

    auto loaded = arborio::load_swc_neuron(fn, opts);
    loaded_morphology res{.morph=loaded.morphology};
    for (const auto& [k, v]: loaded.labels.regions()) res.regions.emplace_back(k, to_string(v));
    for (const auto& [k, v]: loaded.labels.locsets()) res.locsets.emplace_back(k, to_string(v));
    log_info("Loaded SWC (Neuron) {} branches {} ", loaded.segment_tree.size(), loaded.morphology.num_branches());
    return res;
}


loaded_morphology load_arbor_swc(const std::filesystem::path &fn) {
    auto loaded = arborio::load_swc_arbor(fn);
    loaded_morphology res{.morph=loaded.morphology};
    for (const auto& [k, v]: loaded.labels.regions()) res.regions.emplace_back(k, to_string(v));
    for (const auto& [k, v]: loaded.labels.locsets()) res.locsets.emplace_back(k, to_string(v));
    log_info("Loaded SWC (Arbor) {} branches {} ", loaded.segment_tree.size(), loaded.morphology.num_branches());
    return res;
}

loaded_morphology load_neuroml_morph(const std::filesystem::path &fn) {
    arborio::neuroml nml(slurp(fn));
    if (nml.morphology_ids().empty()) log_error("NML file {} has no morphologies.", fn.string());
    auto id = nml.morphology_ids().front();
    auto morph_data = nml.morphology(id);
    if (!morph_data) log_error("Invalid morphology id {} in NML file.");
    auto morph = morph_data.value();
    loaded_morphology result{.morph=morph.morphology};
    for (const auto& [k, v]: morph.labels.regions()) result.regions.emplace_back(k, to_string(v));
    for (const auto& [k, v]: morph.labels.locsets()) result.locsets.emplace_back(k, to_string(v));
    return result;
}

loaded_morphology load_neuroml_cell(const std::filesystem::path &fn) {
    arborio::neuroml nml(slurp(fn));
    if (nml.cell_ids().empty()) log_error("NML file {} has no cells.", fn.string());
    auto id = nml.cell_ids().front();
    auto morph_data = nml.cell_morphology(id);
    if (!morph_data) log_error("Invalid cell id {} in NML file.");
    auto morph = morph_data.value();
    loaded_morphology result{.morph=morph.morphology};
    for (const auto& [k, v]: morph.labels.regions()) result.regions.emplace_back(k, to_string(v));
    for (const auto& [k, v]: morph.labels.locsets()) result.locsets.emplace_back(k, to_string(v));
    return result;
}

loaded_morphology load_asc(const std::filesystem::path &fn) {
    auto m = arborio::load_asc(fn);
    loaded_morphology result{.morph=m.morphology};
    for (const auto& [k, v]: m.labels.regions()) result.regions.emplace_back(k, to_string(v));
    for (const auto& [k, v]: m.labels.locsets()) result.locsets.emplace_back(k, to_string(v));
    return result;
}

static std::unordered_map<std::string,
                          std::unordered_map<std::string,
                                             std::function<loaded_morphology(const std::filesystem::path &fn)>>>
loaders{{".swc", {{"Arbor",   load_arbor_swc},
                  {"Neuron",  load_neuron_swc},
                  {"CNIC",    load_cnic_swc}}},
        {".nml", {{"Cell",    load_neuroml_cell},
                  {"Morph",   load_neuroml_morph}}},
        {".asc", {{"Default", load_asc}}}};

const std::vector<std::string>& get_suffixes() {
    static std::vector<std::string> result;
    if (result.empty()) {
        for (const auto& [k, v]: loaders) result.push_back(k);
    }
    return result;
}

const std::vector<std::string>& get_flavors(const std::string& suffix) {
    static std::unordered_map<std::string, std::vector<std::string>> result;
    if (result.empty()) {
        for (const auto& [s, kvs]: loaders) {
            for (const auto& [k, v]: kvs) {
                result[s].push_back(k);
            }
        }
    }
    return result[suffix];
}

loader_state get_loader(const std::string &extension, const std::string &flavor) {
    if (extension.empty())                    return {"Please select a file.",   {}};
    if (!loaders.contains(extension))         return {"Unknown file type.",      {}};
    if (flavor.empty())                       return {"Please select a flavor.", {}};
    if (!loaders[extension].contains(flavor)) return {"Unknown flavor type.",    {}};
    return {"Ok.", {loaders[extension][flavor]}};
}

}