itkrbflayer.txx

DTMK软件开发包,此为开源软件,是一款很好的医学图像开发资源.

/*=========================================================================

Program:   Insight Segmentation & Registration Toolkit
Module:    $RCSfile: itkRBFLayer.txx,v $
Language:  C++
Date:      $Date: 2007-08-17 13:10:57 $
Version:   $Revision: 1.8 $

Copyright (c) Insight Software Consortium. All rights reserved.
See ITKCopyright.txt or http://www.itk.org/HTML/Copyright.htm for details.

This software is distributed WITHOUT ANY WARRANTY; without even
the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
PURPOSE.  See the above copyright notices for more information.

=========================================================================*/

#ifndef __itkRBFLayerBase_txx
#define __itkRBFLayerBase_txx

#include "itkRBFLayer.h"
#include "itkGaussianRadialBasisFunction.h"

namespace itk
{
  namespace Statistics
    {
    template<class TMeasurementVector, class TTargetVector>
      RBFLayer<TMeasurementVector,TTargetVector>
      ::RBFLayer()
        {
        m_Bias = 1;
        m_NumClasses = 0;
        typedef GaussianRadialBasisFunction<ValueType> GRBFType;
        m_RBF=GRBFType::New();
        m_DistanceMetric = DistanceMetricType::New();
        //  TMeasurementVector origin;

        //  m_DistanceMetric->SetMeasurementVectorSize(origin.Size());
        m_RBF_Dim = 0;
        //
        }


    template<class TMeasurementVector, class TTargetVector>
      RBFLayer<TMeasurementVector,TTargetVector>
      ::~RBFLayer()
        {
        }

    template<class TMeasurementVector, class TTargetVector>
      void
      RBFLayer<TMeasurementVector,TTargetVector>
      ::SetRBF(RBFType* f)
        {
        m_RBF = f;
        this->Modified();
        }
    template<class TMeasurementVector, class TTargetVector>
      void
      RBFLayer<TMeasurementVector,TTargetVector>
      ::SetRBF_Dim(unsigned int dim)
        {
        m_RBF_Dim=dim;
        m_DistanceMetric->SetMeasurementVectorSize(m_RBF_Dim);
        }

    template<class TMeasurementVector, class TTargetVector>
      void
      RBFLayer<TMeasurementVector,TTargetVector>
      ::SetNumberOfNodes(unsigned int c)
        {
        //TMeasurementVector sampleinputvector;
        //m_RBF_Dim= sampleinputvector.Size();
        Superclass::SetNumberOfNodes(c);
        this->m_NodeInputValues.set_size(m_RBF_Dim); //c);
        this->m_NodeOutputValues.set_size(c);
        m_InputErrorValues.set_size(c);
        m_OutputErrorValues.set_size(c);

        if(this->GetLayerTypeCode()!= Self::OUTPUTLAYER)
          {
          //TMeasurementVector temp;
          InternalVectorType temp(m_RBF_Dim);
          for(unsigned int i=0; i<c; i++)
            {
            m_Centers.push_back(temp);
            }
          this->m_NodeOutputValues.set_size(c);
          m_Radii.SetSize(c);
          m_Radii.fill(1.0);
          }
        this->Modified();
        }

    template<class TMeasurementVector, class TTargetVector>
      void
      RBFLayer<TMeasurementVector,TTargetVector>
      ::SetInputValue(unsigned int i, ValueType value)
        {
        this->m_NodeInputValues[i] = value;
        this->Modified();
        }

    template<class TMeasurementVector, class TTargetVector>
      typename RBFLayer<TMeasurementVector,TTargetVector>::ValueType
      RBFLayer<TMeasurementVector,TTargetVector>
      ::GetInputValue(unsigned int i) const
        {
        return m_NodeInputValues[i];
        }
    template<class TMeasurementVector, class TTargetVector>
      void
      RBFLayer<TMeasurementVector,TTargetVector>
      ::SetOutputValue(unsigned int i, ValueType value)
        {
        m_NodeOutputValues(i) = value;
        this->Modified();
        }

    template<class TMeasurementVector, class TTargetVector>
      typename RBFLayer<TMeasurementVector,TTargetVector>::ValueType
      RBFLayer<TMeasurementVector,TTargetVector>
      ::GetOutputValue(unsigned int i) const
        {
        return m_NodeOutputValues(i);
        }

    template<class TMeasurementVector, class TTargetVector>
      void
      RBFLayer<TMeasurementVector,TTargetVector>
      ::SetOutputVector(TMeasurementVector value)
        {
        m_NodeOutputValues = value.GetVnlVector();
        this->Modified();
        }

    template<class TMeasurementVector, class TTargetVector>
      typename RBFLayer<TMeasurementVector,TTargetVector>::ValueType *
      RBFLayer<TMeasurementVector,TTargetVector>
      ::GetOutputVector()
        {
        return m_NodeOutputValues.data_block();
        }

    template<class TMeasurementVector, class TTargetVector>
      void
      RBFLayer<TMeasurementVector,TTargetVector>
      ::SetRadii(ValueType c,unsigned int i)
        {
        m_Radii.SetElement(i,c);
        this->Modified();
        }

    template<class TMeasurementVector, class TTargetVector>
      typename RBFLayer<TMeasurementVector,TTargetVector>::ValueType
      RBFLayer<TMeasurementVector,TTargetVector>
      ::GetRadii(unsigned int i) const
        {
        return m_Radii.GetElement(i);
        }

    template<class TMeasurementVector, class TTargetVector>
      void
      RBFLayer<TMeasurementVector,TTargetVector>
      ::SetCenter(TMeasurementVector c,unsigned int i)
        {
        InternalVectorType temp(c.Size());
        for(unsigned int j=0; j<c.Size(); j++)
          {
          temp[j]=c[j];
          }
        m_Centers[i]=temp; //c;
        this->Modified();
        }

    template<class TMeasurementVector, class TTargetVector>
      typename RBFLayer<TMeasurementVector,TTargetVector>::InternalVectorType
      RBFLayer<TMeasurementVector,TTargetVector>
      ::GetCenter(unsigned int i) const
        {
        if(m_Centers.size()!=0)
          {
          return m_Centers[i];
          }
        else
          {
          return 0;
          }
        }

    template<class TMeasurementVector, class TTargetVector>
      typename RBFLayer<TMeasurementVector,TTargetVector>::ValueType
      RBFLayer<TMeasurementVector,TTargetVector>
      ::GetInputErrorValue(unsigned int n) const
        {
        return m_InputErrorValues[n];
        }

    template<class TMeasurementVector, class TTargetVector>
      typename RBFLayer<TMeasurementVector,TTargetVector>::ValueType *
      RBFLayer<TMeasurementVector,TTargetVector>
      ::GetInputErrorVector()
        {
        return m_InputErrorValues.data_block();
        }

    template<class TMeasurementVector, class TTargetVector>
      void
      RBFLayer<TMeasurementVector,TTargetVector>
      ::SetInputErrorValue(ValueType v, unsigned int i)
        {
        m_InputErrorValues[i] = v;
        this->Modified();
        }

    template<class TMeasurementVector, class TTargetVector>
      void
      RBFLayer<TMeasurementVector,TTargetVector>
      ::ForwardPropagate()
        {
        typename WeightSetInterfaceType::Pointer inputweightset;
        typename InputFunctionInterfaceType::Pointer inputfunction;
        if(this->GetLayerTypeCode()==Self::OUTPUTLAYER)
          {
          typename TransferFunctionInterfaceType::Pointer transferfunction;

          inputfunction = this->GetNodeInputFunction();
          transferfunction = this->GetActivationFunction();
          inputweightset = this->GetInputWeightSet();
          ValueType * inputvalues = inputweightset->GetOutputValues();

          int rows = this->m_NumberOfNodes;
          int cols = this->m_InputWeightSet->GetNumberOfInputNodes();
          vnl_matrix<ValueType> inputmatrix;
          inputmatrix.set_size(rows, cols);
          inputmatrix.copy_in(inputvalues);

          inputfunction->SetSize(cols); //include bias
          for (int j = 0; j < rows; j++)
            {
            vnl_vector<ValueType> temp_vnl;
            temp_vnl.set_size(inputmatrix.cols());
            temp_vnl=inputmatrix.get_row(j);
            m_NodeInputValues.put(j, inputfunction->Evaluate(temp_vnl.data_block()));
            m_NodeOutputValues.put(j, transferfunction->Evaluate(m_NodeInputValues[j]));
            }