-
Notifications
You must be signed in to change notification settings - Fork 179
/
track_contribution.h
166 lines (112 loc) · 4.67 KB
/
track_contribution.h
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
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
/* Copyright (c) 2008-2021 the MRtrix3 contributors.
*
* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/.
*
* Covered Software is provided under this License on an "as is"
* basis, without warranty of any kind, either expressed, implied, or
* statutory, including, without limitation, warranties that the
* Covered Software is free of defects, merchantable, fit for a
* particular purpose or non-infringing.
* See the Mozilla Public License v. 2.0 for more details.
*
* For more details, see http://www.mrtrix.org/.
*/
#ifndef __dwi_tractography_sift_track_contribution_h__
#define __dwi_tractography_sift_track_contribution_h__
#include <cstdint>
#include "header.h"
#include "min_mem_array.h"
#include "math/math.h"
namespace MR
{
namespace DWI
{
namespace Tractography
{
namespace SIFT
{
class Track_fixel_contribution
{ MEMALIGN(Track_fixel_contribution)
public:
Track_fixel_contribution (const uint32_t fixel_index, const float length)
{
const uint32_t length_as_int = std::min (uint32_t(255), uint32_t(std::round (scale_to_storage * length)));
data = (fixel_index & 0x00FFFFFF) | (length_as_int << 24);
}
Track_fixel_contribution() :
data (0) { }
uint32_t get_fixel_index() const { return (data & 0x00FFFFFF); }
float get_length() const { return (uint32_t((data & 0xFF000000) >> 24) * scale_from_storage); }
bool add (const float length)
{
// Allow summing of multiple contributions to a fixel, UNLESS it would cause truncation, in which
// case keep them separate
const uint32_t increment = std::round (scale_to_storage * length);
const uint32_t existing = (data & 0xFF000000) >> 24;
if (existing + increment > 255)
return false;
data = (data & 0x00FFFFFF) | ((existing + increment) << 24);
return true;
}
static void set_scaling (const Header& H)
{
const float max_length = std::sqrt (Math::pow2 (H.spacing(0)) + Math::pow2 (H.spacing(1)) + Math::pow2 (H.spacing(2)));
// TODO Newer mapping performs chordal approximation of length
// Should technically take this into account when setting scaling
scale_to_storage = 255.0 / max_length;
scale_from_storage = max_length / 255.0;
min_length_for_storage = 0.5 / scale_to_storage;
}
// Minimum length that will be non-zero once converted to an integer for word-sharing storage
static float min() { return min_length_for_storage; }
private:
uint32_t data;
static float scale_to_storage, scale_from_storage, min_length_for_storage;
};
/*
// This is a 'safe' version of Track_fixel_contribution that does not use byte-sharing, but requires double the RAM
// Simply comment the class above and un-comment this one to use
class Track_fixel_contribution
{ MEMALIGN(Track_fixel_contribution)
public:
Track_fixel_contribution (const uint32_t fixel_index, const float length) :
fixel (fixel_index),
length (length) { }
Track_fixel_contribution() :
fixel (0),
length (0.0) { }
bool add (const float length) { value += length; return true; }
uint32_t get_fixel_index() const { return fixel; }
float get_length() const { return length; }
static void set_scaling (const Image::Info& in) { min_length_for_storage = 0.0; }
static float min() { return min_length_for_storage; }
private:
uint32_t fixel;
float length;
static float scale_to_storage, scale_from_storage, min_length_for_storage;
};
*/
class TrackContribution : public Min_mem_array<Track_fixel_contribution>
{ MEMALIGN(TrackContribution)
public:
TrackContribution (const vector<Track_fixel_contribution>& in, const float c, const float l) :
Min_mem_array<Track_fixel_contribution> (in),
total_contribution (c),
total_length (l) { }
TrackContribution () :
Min_mem_array<Track_fixel_contribution> (),
total_contribution (0.0),
total_length (0.0) { }
~TrackContribution() { }
float get_total_contribution() const { return total_contribution; }
float get_total_length () const { return total_length; }
private:
const float total_contribution, total_length;
};
}
}
}
}
#endif