NAS/calculateGlobalProp.m at main · vitorchaud/NAS · 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


function [mn_global_prop] = calculateGlobalProp (mn_struct, parameters)

    mn_global_prop.('names') = { 'areaTotalStemDendrites';     'areaSoma';     'areaTotal';     'totalPathLength';     'radial_distance';     'path_length';
                                        'maxEuclidianDistance';     'maxPathDistance';     'averageDiameter';   'numOfBifurcations';     'numOfTerminations';
                                        'numOfBranches';     'numOfStems';     'maxBranchOrder';};


    numOfSegments = mn_struct.('numOfSegments');
    type = mn_struct.('data').('local').('type');
    parent = mn_struct.('data').('local').('parent');
    area = mn_struct.('data').('local').('area');
    segment_length = mn_struct.('data').('local').('segment_length');
    radius = mn_struct.('data').('local').('radius');
    order = mn_struct.('data').('local').('order');
    isBranchPoint = mn_struct.('data').('local').('isBranchPoint');
    isTermination = mn_struct.('data').('local').('isTermination');
    inputImpedance_mod = mn_struct.('data').('local').('inputImpedance_mod');


%     branchPropNames = [parameters.featureNames.branchLevel.morphological; parameters.featureNames.branchLevel.electronic];
%     propsBranchLevels = mn_struct.('data').('branchLevel');

    propNames = [parameters.('featureNames').('treeLevel').('morphological'); parameters.('featureNames').('treeLevel').('electronic')];

    min_array = [];
    lowerQuartile_array = [];
    median_array = [];
    upperQuartile_array = [];
    max_array = [];
    mean_array = [];
    std_array = [];
    total_array = [];


    for j = 1:length(propNames)
        name = char(propNames(j));

        prop = mn_struct.('data').('branchLevel').(name);
        prop(isnan(prop)) = []; %eliminate NaN values

        min_array =             [min_array;             min(prop)];
        lowerQuartile_array =   [lowerQuartile_array;   quantile(prop, 0.25)];
        median_array =          [median_array;          quantile(prop, 0.5)];
        upperQuartile_array =   [upperQuartile_array;   quantile(prop, 0.75)];
        max_array =             [max_array;             max(prop)];
        mean_array =            [mean_array;            mean(prop)];
        std_array =             [std_array;             std(prop)];
        total_array =           [total_array;           sum(prop)];

        mn_global_prop.(name).('min') = min_array;
        mn_global_prop.(name).('lowerQuartile') = lowerQuartile_array;
        mn_global_prop.(name).('median') = median_array;
        mn_global_prop.(name).('upperQuartile') = upperQuartile_array;
        mn_global_prop.(name).('max') = max_array;
        mn_global_prop.(name).('mean') = mean_array;
        mn_global_prop.(name).('std') = std_array;
        mn_global_prop.(name).('total') = total_array;

        min_array = [];
        lowerQuartile_array = [];
        median_array = [];
        upperQuartile_array = [];
        max_array = [];
        mean_array = [];
        std_array = [];
        total_array = [];
    end


    % Obtaining soma area

    if(type(1)==1 && parent(1)==-1)
        areaSoma = area(1);
    else
        error('MNS: I dont know soma index...');
    end

    % Obtaining zero order stem dendrite total area (sum for all zero order compartments)

    areaTotalStemDendrites = 0;

    for i = 1:numOfSegments
        if parent(i)==1 && type(i)~=1
            areaTotalStemDendrites = areaTotalStemDendrites + area(i);
        end
    end

    % Obtaining total area

    areaTotal = sum(area);

    mn_global_prop.('areaTotalStemDendrites') = areaTotalStemDendrites;
    mn_global_prop.('areaSoma') = areaSoma;
    mn_global_prop.('areaTotal') = areaTotal;

    mn_global_prop.('totalPathLength') = sum(segment_length);

    maxEuclidianDistance = max(mn_struct.('data').('local').('radial_distance'));
    maxPathDistance = max(mn_struct.('data').('local').('path_length'));


    segmentDiameters = 2 * radius(type~=1);

    averageDiameter = mean(segmentDiameters);

    mn_global_prop.('maxEuclidianDistance') = maxEuclidianDistance;
    mn_global_prop.('maxPathDistance') = maxPathDistance;
    mn_global_prop.('averageDiameter') = averageDiameter;

%     numOfBifurcations = mn_struct.('data').('somatofugal').('cumNumOfBranchPoints')(end);
%     numOfTerminations = mn_struct.('data').('somatofugal').('cumNumOfTerminations')(end);
%     numOfBranches = mn_struct.('data').('somatofugal').('cumNumOfDendSegments')(end);

    numOfBifurcations = nnz(isBranchPoint);
    numOfTerminations = nnz(isTermination);
    numOfBranches = numOfBifurcations + numOfTerminations;

    mn_global_prop.('numOfBifurcations') = numOfBifurcations;
    mn_global_prop.('numOfTerminations') = numOfTerminations;
    mn_global_prop.('numOfBranches') = numOfBranches;

    mn_global_prop.('maxBranchOrder') = max(order);
    checkingSize = size(inputImpedance_mod);
    if checkingSize(1)==1
        mn_global_prop.('somaticInputImpedance') = inputImpedance_mod(1);
    else
        mn_global_prop.('somaticInputImpedance') = inputImpedance_mod(1,parameters.indexOfSampleFreq);
    end
end