itkMetaSceneConverter.h

Go to the documentation of this file.

/*=========================================================================
 *
 *  Copyright Insight Software Consortium
 *
 *  Licensed under the Apache License, Version 2.0 (the "License");
 *  you may not use this file except in compliance with the License.
 *  You may obtain a copy of the License at
 *
 *         http://www.apache.org/licenses/LICENSE-2.0.txt
 *
 *  Unless required by applicable law or agreed to in writing, software
 *  distributed under the License is distributed on an "AS IS" BASIS,
 *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *  See the License for the specific language governing permissions and
 *  limitations under the License.
 *
 *=========================================================================*/
#ifndef itkMetaSceneConverter_h
#define itkMetaSceneConverter_h

#include "metaScene.h"
#include "itkMetaEvent.h"
#include "itkSceneSpatialObject.h"
#include "itkDefaultStaticMeshTraits.h"
#include "itkMetaConverterBase.h"
#include <string>
#include <map>

namespace itk
{
template< unsigned int NDimensions,
          typename PixelType = unsigned char,
          typename TMeshTraits =
            DefaultStaticMeshTraits< PixelType, NDimensions, NDimensions >
          >
class MetaSceneConverter
{
public:

  typedef itk::SceneSpatialObject< NDimensions > SceneType;
  typedef typename  SceneType::Pointer           ScenePointer;

  typedef MetaConverterBase< NDimensions >              MetaConverterBaseType;
  typedef typename MetaConverterBaseType::Pointer       MetaConverterPointer;
  typedef std::map< std::string, MetaConverterPointer > ConverterMapType;

  MetaSceneConverter();
  ~MetaSceneConverter();

  itkStaticConstMacro(MaximumDepth, unsigned int, 9999999);

  ScenePointer ReadMeta(const char *name);

  bool WriteMeta(SceneType *scene, const char *fileName,
                 unsigned int depth = MaximumDepth,
                 char *spatialObjectTypeName = ITK_NULLPTR);

  const MetaEvent * GetEvent() const { return m_Event; }
  void  SetEvent(MetaEvent *event) { m_Event = event; }

  void SetBinaryPoints(bool binary) { m_BinaryPoints = binary; }

  void SetTransformPrecision(unsigned int precision)
  {
    m_TransformPrecision = precision;
  }
  unsigned int GetTransformPrecision(){ return m_TransformPrecision; }

  void SetWriteImagesInSeparateFile(bool separate)
  {
    m_WriteImagesInSeparateFile = separate;
  }

  void RegisterMetaConverter(const char *metaTypeName,
                             const char *spatialObjectTypeName,
                             MetaConverterBaseType *converter);

  MetaScene * CreateMetaScene(SceneType *scene,
                              unsigned int depth = MaximumDepth,
                              char *name = ITK_NULLPTR);

  ScenePointer CreateSpatialObjectScene(MetaScene *scene);

private:

  typedef itk::SpatialObject< NDimensions >         SpatialObjectType;
  typedef typename SpatialObjectType::Pointer       SpatialObjectPointer;
  typedef typename SpatialObjectType::TransformType TransformType;

  typedef std::list< MetaObject * > MetaObjectListType;

  template <typename TConverter>
    MetaObject *SpatialObjectToMetaObject(SpatialObjectPointer &so)
  {
    typename TConverter::Pointer converter = TConverter::New();
    // needed just for Image & ImageMask
    converter->SetWriteImagesInSeparateFile(this->m_WriteImagesInSeparateFile);
    return converter->SpatialObjectToMetaObject(so.GetPointer());
  }
  template <typename TConverter>
    SpatialObjectPointer MetaObjectToSpatialObject(const MetaObject *mo)
  {
    typename TConverter::Pointer converter = TConverter::New();
    return converter->MetaObjectToSpatialObject(mo);
  }
  void SetTransform(MetaObject *obj, TransformType *transform);

  void SetTransform(SpatialObjectType *so, MetaObject *obj);

  double m_Orientation[100];
  double m_Position[10];
  double m_CenterOfRotation[10];

  MetaEvent *      m_Event;
  bool             m_BinaryPoints;
  bool             m_WriteImagesInSeparateFile;
  unsigned int     m_TransformPrecision;
  ConverterMapType m_ConverterMap;
};
} // end namespace itk

#ifndef ITK_MANUAL_INSTANTIATION
#include "itkMetaSceneConverter.hxx"
#endif

#endif