ArrayFunction.h

Go to the documentation of this file.

/*
    Copyright (C) 2000 PARAPET partners
    Copyright (C) 2000- 2007, Hammersmith Imanet Ltd
    Copyright (C) 2026, University Medical Center Groningen
    This file is part of STIR.
 
    SPDX-License-Identifier: Apache-2.0 AND License-ref-PARAPET-license
 
    See STIR/LICENSE.txt for details
*/
 
/* History:
 
  KT 21/05/2001
  added in_place_apply_array_function_on_1st_index,
  in_place_apply_array_function_on_each_index
 
  KT 06/12/2001
  added apply_array_function_on_1st_index,
  apply_array_function_on_each_index
*/
 
#ifndef __stir_ArrayFunction_H__
#define __stir_ArrayFunction_H__
 
#include "stir/Array.h"
#include "stir/shared_ptr.h"
#include "stir/ArrayFunctionObject.h"
#include <set>
 
START_NAMESPACE_STIR
 
//----------------------------------------------------------------------
// element wise and in place numeric functions
//----------------------------------------------------------------------


template <class elemT>
inline Array<1, elemT>& in_place_log(Array<1, elemT>& v);


template <int num_dimensions, class elemT>
inline Array<num_dimensions, elemT>& in_place_log(Array<num_dimensions, elemT>& v);


template <class elemT>
inline Array<1, elemT>& in_place_exp(Array<1, elemT>& v);


template <int num_dimensions, class elemT>
inline Array<num_dimensions, elemT>& in_place_exp(Array<num_dimensions, elemT>& v);


template <class elemT>
inline Array<1, elemT>& in_place_abs(Array<1, elemT>& v);


template <int num_dimensions, class elemT>
inline Array<num_dimensions, elemT>& in_place_abs(Array<num_dimensions, elemT>& v);


template <class T, class FUNCTION>
inline T& in_place_apply_function(T& v, FUNCTION f);


template <int num_dim, typename elemT, typename FunctionObjectPtr>
inline void in_place_apply_array_function_on_1st_index(Array<num_dim, elemT>& array, FunctionObjectPtr f);


template <int num_dim, typename elemT, typename FunctionObjectPtr>
inline void
apply_array_function_on_1st_index(Array<num_dim, elemT>& out_array, const Array<num_dim, elemT>& in_array, FunctionObjectPtr f);
 
/* local #define used for 2 purposes:
   - in partial template specialisation that uses ArrayFunctionObject types
   - in complete template specialisation for deficient compilers
 
   This is done with a #define to keep code reasonably clean. Also, it allows
   adjusting the type according to what you need.
   Still, it's terribly ugly. Sorry.
 
  Note that you shouldn't/cannot use this define outside of this include file
  (and its .inl) partner.
 
  Ideally, the code should be rewritten to work with any kind of (smart) ptr. TODO
*/
#if !defined(__GNUC__) && !defined(_MSC_VER)
#  define ActualFunctionObjectPtrIter VectorWithOffset<shared_ptr<ArrayFunctionObject<1, elemT>>>::const_iterator
#else
/*
  Puzzlingly, although the code is actually  called with iterators of the type above,
  gcc 3.0 (and others?) gets confused and refuses to compile the
  partial template specialisation (it says it's ambiguous).
  VC also refuses to compile it.
  A work-around is to use the following type
*/
#  define ActualFunctionObjectPtrIter shared_ptr<ArrayFunctionObject<1, elemT>> const*
#endif


// TODO add specialisation that uses ArrayFunctionObject::is_trivial
template <int num_dim, typename elemT, typename FunctionObjectPtrIter>
inline void in_place_apply_array_functions_on_each_index(Array<num_dim, elemT>& array,
                                                         FunctionObjectPtrIter start,
                                                         FunctionObjectPtrIter stop);

template <typename elemT, typename FunctionObjectPtrIter>
inline void
in_place_apply_array_functions_on_each_index(Array<1, elemT>& array, FunctionObjectPtrIter start, FunctionObjectPtrIter stop);


template <int num_dim, typename elemT, typename FunctionObjectPtrIter>
inline void apply_array_functions_on_each_index(Array<num_dim, elemT>& out_array,
                                                const Array<num_dim, elemT>& in_array,
                                                FunctionObjectPtrIter start,
                                                FunctionObjectPtrIter stop);


template <int num_dim, typename elemT>
inline void apply_array_functions_on_each_index(Array<num_dim, elemT>& out_array,
                                                const Array<num_dim, elemT>& in_array,
                                                ActualFunctionObjectPtrIter start,
                                                ActualFunctionObjectPtrIter stop);


// has to be here to get general 1D specialisation to compile
template <typename elemT>
inline void apply_array_functions_on_each_index(Array<1, elemT>& out_array,
                                                const Array<1, elemT>& in_array,
                                                ActualFunctionObjectPtrIter start,
                                                ActualFunctionObjectPtrIter stop);
 
template <typename elemT, typename FunctionObjectPtrIter>

inline void apply_array_functions_on_each_index(Array<1, elemT>& out_array,
                                                const Array<1, elemT>& in_array,
                                                FunctionObjectPtrIter start,
                                                FunctionObjectPtrIter stop);
 
template <int num_dim, typename elemT>
inline void transform_array_to_periodic_indices(Array<num_dim, elemT>& out_array, const Array<num_dim, elemT>& in_array);
template <int num_dim, typename elemT>
inline void transform_array_from_periodic_indices(Array<num_dim, elemT>& out_array, const Array<num_dim, elemT>& in_array);
 
template <typename InputIt, typename elemT>
inline void find_unique_values(std::set<elemT>& values, InputIt begin, InputIt end);
 
// inline bool
// get_spacing_uniform(std::vector<float>& spacing, const std::set<float>& unsorted_block_poss, double epsilon = 1e-4)
// {
//   std::vector<float> sorted_z(unsorted_block_poss.begin(), unsorted_block_poss.end());
//   for (size_t i = 1; i < sorted_z.size(); ++i)
//     {
//       spacing.push_back(std::abs(sorted_z[i] - sorted_z[i - 1]));
//     }
 
//   return std::all_of(spacing.begin(), spacing.end(), [&](float s) { return std::abs(s - spacing.front()) <= epsilon; });
// }
 
END_NAMESPACE_STIR
 
#include "stir/ArrayFunction.inl"
#undef ActualFunctionObjectPtrIter
 
#endif