STIR 6.4.0
BSplines1DRegularGrid.inl
Go to the documentation of this file.
1/*
2 Copyright (C) 2005 - 2009-10-08, Hammersmith Imanet Ltd
3 Copyright (C) 2013, University College London
4 This file is part of STIR.
5
6 SPDX-License-Identifier: Apache-2.0
7
8 See STIR/LICENSE.txt for details
9*/
18
19#include "stir/numerics/BSplinesDetail.inl"
20#include "stir/assign.h"
21START_NAMESPACE_STIR
22
23namespace BSpline
24{
25
26template <typename out_elemT, typename in_elemT, typename constantsT>
29
30template <typename out_elemT, typename in_elemT, typename constantsT>
31BSplines1DRegularGrid<out_elemT, in_elemT, constantsT>::BSplines1DRegularGrid(const std::vector<in_elemT>& input_vector)
32{
33 set_private_values(cubic);
34 set_coef(input_vector.begin(), input_vector.end());
35}
36
37template <typename out_elemT, typename in_elemT, typename constantsT>
38BSplines1DRegularGrid<out_elemT, in_elemT, constantsT>::BSplines1DRegularGrid(const std::vector<in_elemT>& input_vector,
39 const BSplineType this_type)
40{
41 set_private_values(this_type);
42 set_coef(input_vector.begin(), input_vector.end());
43}
44
45template <typename out_elemT, typename in_elemT, typename constantsT>
48
49template <typename out_elemT, typename in_elemT, typename constantsT>
50void
51BSplines1DRegularGrid<out_elemT, in_elemT, constantsT>::set_private_values(BSplineType this_type)
52{
53 this->spline_type = this_type;
54 detail::set_BSpline_values(this->z1, this->z2, this->lambda, this_type);
55}
56
57#if 0
58 // needs to be in .h for VC 6.0
59 template <typename out_elemT, typename in_elemT, typename constantsT>
60 void
61 BSplines1DRegularGrid<out_elemT,in_elemT,constantsT>::
62 set_coef(RandIterIn input_begin_iterator, RandIterIn input_end_iterator)
63 {
64 input_size = input_end_iterator - input_begin_iterator;
65 for(int i=0; i<input_size; ++i)
66 BSplines_coef_vector.push_back(-1);
67
68 BSplines_coef(BSplines_coef_vector.begin(),BSplines_coef_vector.end(),
69 input_begin_iterator, input_end_iterator, z1, z2, lambda);
70 //assert (input_size==static_cast<int>(BSplines_coef_vector.size()-2));
71 }
72#endif
73
74template <typename out_elemT, typename in_elemT, typename constantsT>
75out_elemT
76BSplines1DRegularGrid<out_elemT, in_elemT, constantsT>::compute_BSplines_value(const pos_type relative_position,
77 const bool if_deriv) const
78{
79 assert(relative_position > -input_size + 2);
80 assert(relative_position < 2 * input_size - 4);
81 out_elemT BSplines_value;
82 assign(BSplines_value, 0);
83 const int int_pos = (int)floor(relative_position);
84#if 0
85 for (int k=int_pos-2; k<int_pos+3; ++k)
86 {
87 int index;
88 // if outside-range: implement modulo(-k,2*input_size-2) by hand
89 if (k<0) index=-k;
90 else if (k>=input_size) index=2*input_size-2-k;
91 else index = k;
92 assert(0<=index && index<input_size);
93 BSplines_value += BSplines_product(index, relative_position-k,if_deriv);
94 }
95#else
96 const int kmin = int_pos - 2;
97 const int kmax = int_pos + 2;
98 const int kmax_in_range = std::min(kmax, input_size - 1);
99 int k = kmin;
100 for (; k < 0; ++k)
101 {
102 const int index = -k;
103 assert(0 <= index && index < input_size);
104 BSplines_value += BSplines_product(index, relative_position - k, if_deriv);
105 }
106 for (; k <= kmax_in_range; ++k)
107 {
108 const int index = k;
109 assert(0 <= index && index < input_size);
110 BSplines_value += BSplines_product(index, relative_position - k, if_deriv);
111 }
112 for (; k <= kmax; ++k)
113 {
114 const int index = 2 * input_size - 2 - k;
115 assert(0 <= index && index < input_size);
116 BSplines_value += BSplines_product(index, relative_position - k, if_deriv);
117 }
118#endif
119 return BSplines_value;
120}
121
122template <typename out_elemT, typename in_elemT, typename constantsT>
123out_elemT
124BSplines1DRegularGrid<out_elemT, in_elemT, constantsT>::BSplines(const pos_type relative_position) const
125{
126 return compute_BSplines_value(relative_position, false);
127}
128
129template <typename out_elemT, typename in_elemT, typename constantsT>
130out_elemT
131BSplines1DRegularGrid<out_elemT, in_elemT, constantsT>::BSplines_1st_der(const pos_type relative_position) const
132{
133 return compute_BSplines_value(relative_position, true);
134}
135
136template <typename out_elemT, typename in_elemT, typename constantsT>
137out_elemT
138BSplines1DRegularGrid<out_elemT, in_elemT, constantsT>::BSplines_product(const int index,
139 const pos_type relative_position,
140 const bool if_deriv) const
141{
142 if (if_deriv == true)
143 return BSplines_coef_vector[index] * BSplines_1st_der_weight(relative_position, spline_type);
144 else
145 return BSplines_coef_vector[index] * BSplines_weights(relative_position, spline_type);
146}
147
148template <typename out_elemT, typename in_elemT, typename constantsT>
149const out_elemT
150BSplines1DRegularGrid<out_elemT, in_elemT, constantsT>::operator()(const pos_type relative_position) const
151{
152 return BSplines1DRegularGrid<out_elemT, in_elemT, constantsT>::BSplines(relative_position);
153}
154
155//*
156template <typename out_elemT, typename in_elemT, typename constantsT>
157const std::vector<out_elemT>
158BSplines1DRegularGrid<out_elemT, in_elemT, constantsT>::BSplines_output_sequence(
159 RandIterOut output_relative_position_begin_iterator, // relative_position might be better float
160 RandIterOut output_relative_position_end_iterator)
161{
162 std::vector<pos_type> output_vector(output_relative_position_end_iterator - output_relative_position_begin_iterator);
163
164 for (RandIterOut current_iterator = output_vector.begin(),
165 current_relative_position_iterator = output_relative_position_begin_iterator;
166 current_iterator != output_vector.end() && current_relative_position_iterator != output_relative_position_end_iterator;
167 ++current_iterator, ++current_relative_position_iterator)
168 *current_iterator = BSplines1DRegularGrid<out_elemT, in_elemT, constantsT>::BSplines(*current_relative_position_iterator);
169
170 return output_vector;
171}
172template <typename out_elemT, typename in_elemT, typename constantsT>
173const std::vector<out_elemT>
174BSplines1DRegularGrid<out_elemT, in_elemT, constantsT>::BSplines_output_sequence(std::vector<pos_type> output_relative_position)
175{
176 return BSplines_output_sequence(output_relative_position.begin(), output_relative_position.end());
177}
178
179} // namespace BSpline
180
181END_NAMESPACE_STIR
BSplinesDetail.inl
Implementation of the B-Splines Interpolation.
assign.h
defines the stir::assign function to assign values to different data types
stir::BSpline::BSplines1DRegularGrid::~BSplines1DRegularGrid
~BSplines1DRegularGrid()
destructor
Definition BSplines1DRegularGrid.inl:46
stir::BSpline::BSplines1DRegularGrid::BSplines1DRegularGrid
BSplines1DRegularGrid()
default constructor: no input
Definition BSplines1DRegularGrid.inl:27
stir::BSpline::BSplines1DRegularGrid::operator()
const out_elemT operator()(const pos_type relative_position) const
same as BSplines()
Definition BSplines1DRegularGrid.inl:150
stir::BSpline::BSplines_1st_der_weight
pos_type BSplines_1st_der_weight(const pos_type relative_position, const BSplineType spline_type)
return value of the first derivative of the spline
stir::BSpline::pos_type
double pos_type
The type used for relative positions between the grid points.
Definition BSplines.h:32
stir::BSpline::BSplines_weights
pos_type BSplines_weights(const pos_type relative_position, const BSplineType spline_type)
return spline value
stir::BSpline::BSplineType
BSplineType
enum providing constants to define the type of B-Spline used for interpolation
Definition BSplines.h:38
stir::BSpline::BSplines_coef
void BSplines_coef(RandIterOut c_begin_iterator, RandIterOut c_end_iterator, IterT input_begin_iterator, IterT input_end_iterator, const constantsT z1, const constantsT z2, const constantsT lambda)
compute BSpline coefficients that gives the BSpline that interpolates the given data
Definition BSplines_coef.inl:56
Generated on Wed May 27 2026 17:04:05 for STIR by doxygen 1.13.2