mitkDataTreeFilterFunctions.h

Go to the documentation of this file.

/*=========================================================================
 
Program:   Medical Imaging & Interaction Toolkit
Language:  C++
Date:      $Date$
Version:   $Revision$
 
Copyright (c) German Cancer Research Center, Division of Medical and
Biological Informatics. All rights reserved.
See MITKCopyright.txt or https://www.mitk.org/copyright.html 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 MITK_DATATREEFILTERFUNCTOINS_H_INCLUDED
#define MITK_DATATREEFILTERFUNCTOINS_H_INCLUDED

#include <mitkDataNode.h>
#include "MitkExtExports.h"

#include <mitkProperties.h>
#include <mitkDataStorage.h>

namespace mitk
{
  class DataNode; 

   class MitkExt_EXPORT DataTreeFilterFunction
  {
    public:
      virtual ~DataTreeFilterFunction() {}
      virtual bool operator()(DataNode*) const;
      virtual bool NodeMatches(DataNode*) const = 0;
      virtual DataTreeFilterFunction* Clone() const = 0;
  };

  template <class T>
  class IsBaseDataType : public DataTreeFilterFunction
  {
    public:
      virtual bool NodeMatches(DataNode* node) const
      {
        return ( node != NULL && node->GetData() && dynamic_cast<T*>(node->GetData()) );
      }

      virtual DataTreeFilterFunction* Clone() const
      {
        return new IsBaseDataType<T>();
      }

      virtual ~IsBaseDataType() {}
  };

  template <class T>
  class IsBaseDataTypeWithProperty : public DataTreeFilterFunction
  {
    public:

      IsBaseDataTypeWithProperty(const char* propertyName)
      :m_PropertyName(propertyName)
      {
      }
      
      virtual bool NodeMatches(DataNode* node) const
      {
        return (    node != NULL && node->GetData()                               // node is not NULL, and node->GetData is also not NULL
                 && dynamic_cast<T*>(node->GetData() )                            // data is of a certain type
                 && (   node->GetProperty(m_PropertyName.c_str())!= NULL          // there is a certain property
                    )
                );
      }

      virtual DataTreeFilterFunction* Clone() const
      {
        return new IsBaseDataTypeWithProperty<T>(m_PropertyName.c_str());
      }

      virtual ~IsBaseDataTypeWithProperty() {}

    private:
      
      std::string m_PropertyName;
  };

  template <class T>
  class IsBaseDataTypeWithBoolProperty : public DataTreeFilterFunction
  {
    public:

      IsBaseDataTypeWithBoolProperty(const char* propertyName)
      :m_PropertyName(propertyName)
      {
      }
      
      virtual bool NodeMatches(DataNode* node) const
      {
        bool propVal(false);
        return (    node != NULL && node->GetData()                            // node is not NULL, and node->GetData is also not NULL
                 && dynamic_cast<T*>( node->GetData() )                       // data is of a certain type
                 && node->GetPropertyValue(m_PropertyName.c_str(), propVal)  // there is a certain BoolProperty
                 && propVal
                );
      }

      virtual DataTreeFilterFunction* Clone() const
      {
        return new IsBaseDataTypeWithBoolProperty<T>(m_PropertyName.c_str());
      }

      virtual ~IsBaseDataTypeWithBoolProperty() {}

    private:
      
      std::string m_PropertyName;
  };


  template <class T>
  class IsBaseDataTypeWithoutProperty : public DataTreeFilterFunction
  {
    public:

      IsBaseDataTypeWithoutProperty(const char* propertyName)
      :m_PropertyName(propertyName)
      {
      }
      
      virtual bool NodeMatches(DataNode* node) const
      {
        bool propVal(false);
        bool propertyExists(false);

        if (node)
          propertyExists = node->GetPropertyValue(m_PropertyName.c_str(), propVal );

        return (    node != NULL && node->GetData()         // node is not NULL, and node->GetData is also not NULL
                 && dynamic_cast<T*>(node->GetData() )     // data is of a certain type
                 && ( !propertyExists || !propVal ));     // the property does not exist, OR its value is false
      }

      virtual DataTreeFilterFunction* Clone() const
      {
        return new IsBaseDataTypeWithoutProperty<T>(m_PropertyName.c_str());
      }

      virtual ~IsBaseDataTypeWithoutProperty() {}

    private:
      
      std::string m_PropertyName;
  };


  // some default filters in mitk:: namespace for use by clients of mitk::DataTreeFilter
  
  class MitkExt_EXPORT IsDataNode : public DataTreeFilterFunction
  {
    public:
      virtual ~IsDataNode() {}
      virtual bool NodeMatches(DataNode*) const;
      virtual DataTreeFilterFunction* Clone() const;
  };

  class MitkExt_EXPORT IsGoodDataNode : public DataTreeFilterFunction
  {
    public:
      virtual ~IsGoodDataNode() {}
      virtual bool NodeMatches(DataNode*) const;
      virtual DataTreeFilterFunction* Clone() const;
  };

  class MitkExt_EXPORT IsInResultSet : public DataTreeFilterFunction
  {
    public:
      IsInResultSet( std::set<const DataNode*> rs )
        :m_ResultSet(rs)
      {
      }

      IsInResultSet(const DataStorage::SetOfObjects* rs)
      {
        if (rs)
        {
          for (DataStorage::SetOfObjects::const_iterator iter = rs->begin();
               iter != rs->end();
               ++iter)
          {
            m_ResultSet.insert( iter->GetPointer() );
          }
        }
      }

      virtual ~IsInResultSet() {}
      virtual bool NodeMatches(DataNode*) const;
      virtual DataTreeFilterFunction* Clone() const;
    protected:
      //DataStorage::SetOfObjects::ConstPointer m_ResultSet;
      std::set<const DataNode*> m_ResultSet;
  };

  template <unsigned int DIM>
  class IsImageWithDimensionAndWithoutProperty : public DataTreeFilterFunction
  {
    public:

      IsImageWithDimensionAndWithoutProperty(const char* propertyName)
      :m_PropertyName(propertyName)
      {
      }
      
      virtual bool NodeMatches(DataNode* node) const
      {
        return (    node != NULL && node->GetData()                                // node is not NULL, and node->GetData is also not NULL
                 && dynamic_cast<mitk::Image*>(node->GetData() )                            // data is an image
                 && (dynamic_cast<mitk::Image*>(node->GetData() )->GetDimension() == DIM)
                 && (   node->GetProperty(m_PropertyName.c_str()) == NULL    // there is a certain property
                    )
                );
      }

      virtual DataTreeFilterFunction* Clone() const
      {
        return new IsImageWithDimensionAndWithoutProperty<DIM>(m_PropertyName.c_str());
      }

      virtual ~IsImageWithDimensionAndWithoutProperty() {}

    private:
      
      std::string m_PropertyName;
  };

  template <unsigned int DIM>
  class IsImageWithMinimumDimension : public DataTreeFilterFunction
  {
    public:
      
      virtual bool NodeMatches(DataNode* node) const
      {
        return (    node != NULL && node->GetData()                                // node is not NULL, and node->GetData is also not NULL
                 && dynamic_cast<mitk::Image*>(node->GetData() )                            // data is an image
                 && (dynamic_cast<mitk::Image*>(node->GetData() )->GetDimension() >= DIM)
                );
      }

      virtual DataTreeFilterFunction* Clone() const
      {
        return new IsImageWithMinimumDimension<DIM>();
      }

      virtual ~IsImageWithMinimumDimension() {}
  };

} // namespace mitk

#endif
// vi: textwidth=90