void load(input_archive& ar, boost::multi_array<T, N, Allocator>& marray, unsigned)
{
boost::array<std::size_t, N> shape;
ar & shape;
marray.resize(shape);
ar & make_array(marray.data(), marray.num_elements());
}
void precompute(double distance, double scalex, double scaley)
{
double const radius2 = distance * distance;
width = 2* ceil(distance / scalex) + 1;
height = 2* ceil(distance / scaley) + 1;
in_distance.resize(boost::extents[height][width]);
std::fill(in_distance.data(), in_distance.data() + in_distance.num_elements(), false);
parents.resize(boost::extents[height][width]);
std::fill(parents.data(), parents.data() + parents.num_elements(), std::make_pair(-1, -1));
centerx = width / 2;
centery = height / 2;
parents[centery][centerx] = std::make_pair(-1, -1);
for (unsigned int y = 0; y < height; ++y)
{
for (unsigned int x = 0; x < width; ++x)
{
int dx = (centerx - x);
int dy = (centery - y);
if (dx == 0 && dy == 0) continue;
double d2 = dx * dx * scalex * scalex + dy * dy * scaley * scaley;
in_distance[y][x] = (d2 < radius2);
if (abs(dx) > abs(dy))
{
int parentx = x + dx / abs(dx);
int parenty = y + rint(static_cast<double>(dy) / abs(dx));
parents[y][x] = std::make_pair(parentx, parenty);
}
else
{
int parentx = x + rint(static_cast<double>(dx) / abs(dy));
int parenty = y + dy / abs(dy);
parents[y][x] = std::make_pair(parentx, parenty);
}
}
}
}
void save( Archive & ar,
const boost::multi_array<double,2> & t,
const unsigned int file_version )
{
typedef boost::multi_array<double,2> multi_array_;
typedef typename multi_array_::size_type size_;
size_ n0 = ( t.shape()[0] );
ar << BOOST_SERIALIZATION_NVP( n0 );
size_ n1 = ( t.shape()[1] );
ar << BOOST_SERIALIZATION_NVP( n1 );
ar << boost::serialization::make_array( t.data(),
t.num_elements() );
}
void load( Archive & ar,
boost::multi_array<double,2> & t,
const unsigned int file_version )
{
typedef boost::multi_array<double,2> multi_array_;
typedef typename multi_array_::size_type size_;
size_ n0;
ar >> BOOST_SERIALIZATION_NVP( n0 );
size_ n1;
ar >> BOOST_SERIALIZATION_NVP( n1 );
t.resize( boost::extents[n0][n1] );
ar >> make_array( t.data(), t.num_elements() );
}
void fill(boost::multi_array<V1,NumDims,Allocator> &x, const V2 &v) {
std::fill_n(x.data(), x.num_elements(), v);
}
/** Returns the total number of elements in the buffer
Equal to get_range()[0] * ... * get_range()[dimensions-1].
*/
auto get_count() const {
return allocation.num_elements();
}
void save(output_archive& ar, const boost::multi_array<T, N,
Allocator>& marray, unsigned)
{
ar & make_array(marray.shape(), marray.num_dimensions());
ar & make_array(marray.data(), marray.num_elements());
}
/** \brief get the centroid of the neighbourhood of an image pixel given by it's offset */
valarray<double> centroid::operator()(const size_t& l) const
{
const int scope = 1;
//convert the raveled index to 3D indices
size_t
i = l / image.strides()[0],
j = (l % image.strides()[0]) / image.strides()[1],
k = (l % image.strides()[0]) % image.strides()[1];
//cout<<"l="<<l<<" -> i="<<i<<" j="<<j<<" k="<<k<<" ... ";
//the data of the neighbourhood view are copied together for the coder's sanity
boost::multi_array<float,3> ngb =
image[boost::indices
[image.shape()[0]<2*scope+1 ? range() : range(i-scope, i+scope+1)]
[image.shape()[1]<2*scope+1 ? range() : range(j-scope, j+scope+1)]
[image.shape()[2]<2*scope+1 ? range() : range(k-scope, k+scope+1)]
];
//Find the extrema of the neighbourhood.
std::pair<float*, float*> minmax = boost::minmax_element(ngb.origin(), ngb.origin()+ngb.num_elements());
//If the neighbourhood contains a negative pixel, we are at the edge of a Fourier filtering artefact that should not be considered a particle
if(*minmax.first < 0)
return valarray<double>(-1.0, 3);
//marking non local maxima (including diagonals)
if(image.origin()[l] != *minmax.second)
return valarray<double>(-1.0, 3);
//calculation of the intensity centroid
valarray<double> c(0.0,3);
double total_w = 0.0;
float *px = ngb.origin();
for(int x=0; x<ngb.shape()[0];++x)
for(int y=0; y<ngb.shape()[1];++y)
for(int z=0; z<ngb.shape()[2];++z)
{
const double weight = pow((double)(x-scope), 2) + pow((double)(y-scope), 2) + pow((double)(z-scope), 2) * (double)(*px);
c[0] += (x-scope)*weight;
c[1] += (y-scope)*weight;
c[2] += (z-scope)*weight;
total_w += weight ;
px++;
}
//cout<<c[0]<<"\t"<<c[1]<<"\t"<<c[2]<<endl;
//cout<<"divide by a weight of "<<total_w<<endl;
c /= total_w/pow(2.0*scope+1, 2);
//cout<<c[0]<<"\t"<<c[1]<<"\t"<<c[2]<<endl;
//c /= (double)accumulate(ngb.origin(), ngb.origin()+ngb.num_elements(), 0.0);
//double sum = accumulate(ngb.origin(),ngb.origin()+ngb.num_elements(),0.0);
//cout<<"valarrays ... ";
/*valarray<double> c(0.0,3), pos(0.0,3), middle(0.0,3);
for(size_t d=0; d<3;++d)
middle[d] = ngb.shape()[d]/3;
float *v = ngb.origin();
for(pos[0]=0;pos[0]<ngb.shape()[0];++pos[0])
for(pos[1]=0;pos[1]<ngb.shape()[1];++pos[1])
for(pos[2]=0;pos[2]<ngb.shape()[2];++pos[2])
c += (pos-middle) * (*v++);//pow(*v++, 2.0f);
c /= image.origin()[l];//pow(image.origin()[l], 2.0f);
for(size_t d=0;d<3;++d)
c[d] = (c[d]<0?-1:1) * sqrt(abs(c[d]))/4.5;*/
c[0] += i;
c[1] += j;
c[2] += k;
return c;
};