kernel.h

Go to the documentation of this file.

#ifndef _DLRCOMPUTERVISION_KERNEL_H_
#define _DLRCOMPUTERVISION_KERNEL_H_

#include <dlrNumeric/array2D.h>

namespace dlr {

  namespace computerVision {
    
    template <class ELEMENT_TYPE>
    class Kernel
    {
    public:

      /* ******** Public typedefs ******** */

      typedef ELEMENT_TYPE ElementType;


      /* ******** Public member functions ******** */

      Kernel();

    
      Kernel(const Kernel<ELEMENT_TYPE>& source);

    
      Kernel(const Array2D<ElementType>& source);

    
      Kernel(size_t rows, size_t columns, ElementType* const dataPtr);


      Kernel(const Array1D<ElementType>& rowArray,
             const Array1D<ElementType>& columnArray);

    
      virtual
      ~Kernel();


      Array2D<ElementType>
      getArray2D() const;
    

      Array1D<ElementType>
      getColumnComponent() const;


      size_t getColumns() const;


      Array1D<ElementType>
      getRowComponent() const;


      size_t getRows() const;

    
      bool
      isSeparable() const {return m_isSeparable;}


      void
      setArray2D(const Array2D<ElementType>& dataArray);


      void
      setSeparableComponents(const Array1D<ElementType>& rowArray,
                             const Array1D<ElementType>& columnArray);


    private:

      Array2D<ElementType> m_data;
      bool m_isSeparable;
      size_t m_separableColumns;
      size_t m_separableRows;

    };

  } // namespace computerVision

} // namespace dlr


/* =============== Implementation follows =============== */


namespace dlr {

  namespace computerVision {

    // Default constructor initializes to zero size.
    template <class ELEMENT_TYPE>
    Kernel<ELEMENT_TYPE>::
    Kernel()
      : m_data(),
        m_isSeparable(false),
        m_separableColumns(0),
        m_separableRows(0)
    {
      // Empty.
    }
    
    
    // The copy constructor does a shallow copy.
    template <class ELEMENT_TYPE>
    Kernel<ELEMENT_TYPE>::
    Kernel(const Kernel<ELEMENT_TYPE> &source)
      : m_data(source.m_data.copy()),
        m_isSeparable(source.m_isSeparable),
        m_separableColumns(source.m_separableColumns),
        m_separableRows(source.m_separableRows)
    {
      // Empty.
    }
      
    
    // This constructor allows us to implicitly make a Kernel instance
    // from an Array2D.
    template <class ELEMENT_TYPE>
    Kernel<ELEMENT_TYPE>::
    Kernel(const Array2D<ElementType> &source)
      : m_data(source.copy()),
        m_isSeparable(false),
        m_separableColumns(0),
        m_separableRows(0)
    {
      // Empty.
    }
    

    // Construct a kernel around external data.
    template <class ELEMENT_TYPE>
    Kernel<ELEMENT_TYPE>::
    Kernel(size_t rows, size_t columns, ElementType* const dataPtr)
      : m_data(rows, columns),
        m_isSeparable(false),
        m_separableColumns(0),
        m_separableRows(0)
    {
      m_data.copy(dataPtr);
    }


    // This constructor allows us to implicitly make a separable
    // Kernel instance from a pair of Array1D instances.
    template <class ELEMENT_TYPE>
    Kernel<ELEMENT_TYPE>::
    Kernel(const Array1D<ElementType>& rowArray,
           const Array1D<ElementType>& columnArray)
      : m_data(1, rowArray.size() + columnArray.size()),
        m_isSeparable(true),
        m_separableColumns(rowArray.size()),
        m_separableRows(columnArray.size())
    {
      std::copy(rowArray.begin(), rowArray.end(), m_data.begin());
      std::copy(columnArray.begin(), columnArray.end(),
                m_data.begin() + rowArray.size());
    }


    // Destroys the Kernel instance and deletes the internal data
    // store.
    template <class ELEMENT_TYPE>
    Kernel<ELEMENT_TYPE>::
    ~Kernel()
    {
      // Empty.
    }


    // Return a copy of the kernel data in an Array2D object.
    template <class ELEMENT_TYPE>
    Array2D<ELEMENT_TYPE>
    Kernel<ELEMENT_TYPE>::
    getArray2D() const
    {
      if(m_isSeparable) {
        Array2D<ELEMENT_TYPE> synthesizedArray(
          m_separableRows, m_separableColumns);
        typename Array2D<ELEMENT_TYPE>::iterator resultIterator =
          synthesizedArray.begin();
        for(size_t rowIndex = 0; rowIndex < m_separableRows; ++rowIndex) {
          for(size_t columnIndex = 0; columnIndex < m_separableColumns;
              ++columnIndex) {
            *resultIterator =
              m_data[columnIndex] * m_data[m_separableColumns + rowIndex];
            ++resultIterator;
          }
        }
        return synthesizedArray;
      }
      // Not separable.
      return m_data.copy();
    }
    

    // This method is only valid for separable kernels; it returns
    // the separable kernel component which is parallel to the columns
    // of the image.
    template <class ELEMENT_TYPE>
    Array1D<ELEMENT_TYPE>
    Kernel<ELEMENT_TYPE>::
    getColumnComponent() const
    {
      Array1D<ELEMENT_TYPE> columnComponent(m_separableRows);
      columnComponent.copy(m_data.begin() + m_separableColumns);
      return columnComponent;
    }

    
    // This member function returns the number of columns in the kernel.
    template <class ELEMENT_TYPE>
    size_t
    Kernel<ELEMENT_TYPE>::
    getColumns() const
    {
      if(this->isSeparable()) {
        return m_separableColumns;
      }
      return m_data.columns();
    }


    // This method is only valid for separable kernels; it returns
    // the separable kernel component which is parallel to the rows
    // of the image.
    template <class ELEMENT_TYPE>
    Array1D<ELEMENT_TYPE>
    Kernel<ELEMENT_TYPE>::
    getRowComponent() const
    {
      Array1D<ELEMENT_TYPE> rowComponent(m_separableColumns);
      rowComponent.copy(m_data.begin());
      return rowComponent;
    }


    // This member function returns the number of rows in the kernel.
    template <class ELEMENT_TYPE>
    size_t
    Kernel<ELEMENT_TYPE>::
    getRows() const
    {
      if(this->isSeparable()) {
        return m_separableRows;
      }
      return m_data.rows();
    }

  
    // This method allows the user to set the contents of the kernel.
    template <class ELEMENT_TYPE>
    void
    Kernel<ELEMENT_TYPE>::
    setArray2D(const Array2D<ElementType>& dataArray)
    {
      m_isSeparable = false;
      m_data = dataArray.copy();
      m_separableColumns = 0;
      m_separableRows = 0;
    }


    // This method allows the user to set the contents of a separable
    // kernel.
    template <class ELEMENT_TYPE>
    void
    Kernel<ELEMENT_TYPE>::
    setSeparableComponents(const Array1D<ElementType>& rowArray,
                           const Array1D<ElementType>& columnArray)
    {
      m_isSeparable = true;
      m_data.reinit(1, rowArray.size() + columnArray.size());
      std::copy(rowArray.begin(), rowArray.end(), m_data.begin());
      std::copy(columnArray.begin(), columnArray.end(),
                m_data.begin() + rowArray.size());
      m_separableColumns = rowArray.size();
      m_separableRows = columnArray.size();
    }
    
  } // namespace computerVision

} // namespace dlr

#endif /* #ifndef _DLRCOMPUTERVISION_KERNEL_H_ */