itkMetaSceneConverter.h

Go to the documentation of this file.

/*=========================================================================
 *
 *  Copyright NumFOCUS
 *
 *  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
 *
 *         https://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 "itkObject.h"
#include "itkDefaultStaticMeshTraits.h"
 
#include "metaScene.h"
#include "itkMetaEvent.h"
#include "itkSpatialObject.h"
#include "itkMetaConverterBase.h"
 
#include <string>
#include <map>
 
namespace itk
{
template <unsigned int VDimension = 3,
          typename PixelType = unsigned char,
          typename TMeshTraits = DefaultStaticMeshTraits<PixelType, VDimension, VDimension>>
class ITK_TEMPLATE_EXPORT MetaSceneConverter : public Object
{
public:

  using Self = MetaSceneConverter;
  using Superclass = Object;
  using Pointer = SmartPointer<Self>;
  using ConstPointer = SmartPointer<const Self>;
 
  itkNewMacro(Self);

  itkOverrideGetNameOfClassMacro(MetaSceneConverter);

  using SpatialObjectType = itk::SpatialObject<VDimension>;
  using SpatialObjectPointer = typename SpatialObjectType::Pointer;
  using SpatialObjectConstPointer = typename SpatialObjectType::ConstPointer;

  using MetaConverterBaseType = MetaConverterBase<VDimension>;
  using MetaConverterPointer = typename MetaConverterBaseType::Pointer;
  using ConverterMapType = std::map<std::string, MetaConverterPointer>;

  itkSetMacro(MetaIOVersion, unsigned int);
  itkGetConstMacro(MetaIOVersion, unsigned int);

  SpatialObjectPointer
  ReadMeta(const std::string & name);

  bool
  WriteMeta(const SpatialObjectType * soScene,
            const std::string &       fileName,
            unsigned int              depth = SpatialObjectType::MaximumDepth,
            const std::string &       soName = "");
 
  itkGetMacro(Event, MetaEvent *);
  itkSetObjectMacro(Event, MetaEvent);

  itkSetMacro(BinaryPoints, bool);
  itkGetConstMacro(BinaryPoints, bool);
  itkBooleanMacro(BinaryPoints);

  itkSetMacro(TransformPrecision, unsigned int);
  itkGetMacro(TransformPrecision, unsigned int);

  itkSetMacro(WriteImagesInSeparateFile, bool);
  itkGetConstMacro(WriteImagesInSeparateFile, bool);
  itkBooleanMacro(WriteImagesInSeparateFile);

  void
  RegisterMetaConverter(const std::string &     metaTypeName,
                        const std::string &     spatialObjectTypeName,
                        MetaConverterBaseType * converter);

  MetaScene *
  CreateMetaScene(const SpatialObjectType * soScene,
                  unsigned int              depth = SpatialObjectType::MaximumDepth,
                  const std::string &       name = "");
 
  SpatialObjectPointer
  CreateSpatialObjectScene(MetaScene * mScene);
 
protected:
  MetaSceneConverter();
  ~MetaSceneConverter() override = default;
 
private:
  using TransformType = typename SpatialObjectType::TransformType;
 
  using MetaObjectListType = std::list<MetaObject *>;
 
  template <typename TConverter>
  MetaObject *
  SpatialObjectToMetaObject(SpatialObjectConstPointer & so)
  {
    auto converter = TConverter::New();
    // needed just for Image & ImageMask
    converter->SetMetaIOVersion(m_MetaIOVersion);
    converter->SetWriteImagesInSeparateFile(this->m_WriteImagesInSeparateFile);
    return converter->SpatialObjectToMetaObject(so);
  }
  template <typename TConverter>
  SpatialObjectPointer
  MetaObjectToSpatialObject(const MetaObject * mo)
  {
    auto converter = TConverter::New();
    converter->SetMetaIOVersion(m_MetaIOVersion);
    return converter->MetaObjectToSpatialObject(mo);
  }
  void
  SetTransform(MetaObject * obj, const TransformType * transform);
 
  void
  SetTransform(SpatialObjectType * so, const MetaObject * meta);
 
  MetaEvent *      m_Event{};
  bool             m_BinaryPoints{};
  bool             m_WriteImagesInSeparateFile{};
  unsigned int     m_TransformPrecision{};
  ConverterMapType m_ConverterMap{};
  unsigned int     m_MetaIOVersion{ 0 };
};
} // end namespace itk
 
#ifndef ITK_MANUAL_INSTANTIATION
#  include "itkMetaSceneConverter.hxx"
#endif
 
#endif