[ITK-users] VariableLengthVector and multiplication

[Cyril Mory]

Thanks for this answer.

I am trying the approach you suggested, and would like to write a dot 
product functor that would work either on scalars (in which case it 
would perform a simple product) or on itk::VariableLengthVector of 
scalars (in which case it would perform a dot product).

I found the "itk::NumericTraits<TPixel>::GetLength()" method, which 
works in both cases, and so I tried this:


namespace Functor
{
   template< class TPixel, class TInternal>
   class DotProduct
   {
   public:
     DotProduct() {}
     ~DotProduct() {}
     bool operator!=(const DotProduct &) const
     {
       return false;
     }

     bool operator==(const DotProduct & other) const
     {
       return !( *this != other );
     }

     inline TInternal operator()(const TPixel & A, const TPixel & B) const
     {
     TInternal out = 0;
     for (unsigned int component=0; component < 
itk::NumericTraits<TPixel>::GetLength(); component++)
       {
       out += A[component] * B[component];
       }
     return out;
     }
   };
} // end namespace functor


But it does not compile with itk::Image inputs, since the pixels A and B 
have no [ ] operator. Is there a standard way around this problem ?

Regards,
Cyril

On 22/11/2017 14:38, Lowekamp, Bradley (NIH/NLM/LHC) [C] wrote:
> Hello,
>
> There are an incredible number of different per-pixel operations that could be implemented as ITK filters. We cannot provide them all. Many of the basic operations are implemented as ITK filters these include performing the basic C++ operators, such as +, -, * and /, on a per-pixel basis.
>
> As you indicate there are many possible meanings for multiplication of vector images, which can lead to confusion.
>
> ITK has a flexible set of Unary[1], Binary[2] functor filters. Classes like the MultiplyImageFilter[3], are implemented by deriving from the base functor classes. However it is easier to just use the base functor filter and set the proper or custom functor, as in this example [4].
>
> It is fairly easy to write a functor for your specific purposes by following the existing set [5]. It is common for filters to internally define a private functor to perform one step in a large filter. Moving from writing for loops on pixels to writing custom functors is part of good usage of ITK.
>
>
> Brad
>
>
> [1] https://itk.org/Doxygen/html/classitk_1_1UnaryFunctorImageFilter.html
> [2] https://itk.org/Doxygen/html/classitk_1_1BinaryFunctorImageFilter.html
> [3] https://itk.org/Doxygen/html/classitk_1_1MultiplyImageFilter.html
> [4] https://itk.org/Doxygen/html/WikiExamples_2ImageProcessing_2BinaryFunctorImageFilter_8cxx-example.html#_a1
>
> On 11/22/17, 5:15 AM, "Cyril Mory" <cyril.mory at creatis.insa-lyon.fr> wrote:
>
>      Dear ITK users,
>      
>      I am using itk::VectorImage in some of my code, which uses
>      itk::VariableLengthVector as pixel type. And I am wondering why
>      itk::VariableLengthVector has so little support for multiplication.
>      Currently, the * operator only supports multiplication by a scalar.
>      
>      It probably isn't simple, but I would need three additional kinds of
>      multiplication:
>      
>      - dot product with another VariableLengthVector (that has the same
>      length, although it is probably a waste of time to perform the check
>      every time), returning a scalar
>      
>      - component-wise multiplication, returning a VariableLengthVector of the
>      same length
>      
>      - left or right multiplication with a matrix (possibly an
>      itk::VariableSizeMatrix) that has the correct size, but I understand
>      that this is probably the most complex one, and since it only occurs
>      rarely in my code, I can handle it with conversions to vnl::vector and
>      vnl::matrix
>      
>      Are there constraints that prevent at least the dot product and
>      component-wise multiplication operators from being implemented ? If not,
>      then I'd be happy to give it a try. Since both differ only by the return
>      type, two different operators would have to be used (I guess). Do you
>      have suggestions (which one should use *, and what should be the other
>      operator) ? In itk::Vector and itk::CovariantVector, the * operator is
>      used for dot product.
>      
>      Regards,
>      
>      Cyril
>      
>      
>      The ITK community is transitioning from this mailing list to discourse.itk.org. Please join us there!
>      ________________________________
>      Powered by www.kitware.com
>      
>      Visit other Kitware open-source projects at
>      http://www.kitware.com/opensource/opensource.html
>      
>      Kitware offers ITK Training Courses, for more information visit:
>      http://www.kitware.com/products/protraining.php
>      
>      Please keep messages on-topic and check the ITK FAQ at:
>      http://www.itk.org/Wiki/ITK_FAQ
>      
>      Follow this link to subscribe/unsubscribe:
>      http://public.kitware.com/mailman/listinfo/insight-users
>      
>
>