imstkImageData.h

/*
** This file is part of the Interactive Medical Simulation Toolkit (iMSTK)
** iMSTK is distributed under the Apache License, Version 2.0.
** See accompanying NOTICE for details.
*/

#pragma once

#include "imstkMacros.h"
#include "imstkPointSet.h"
#include "imstkTypes.h"

namespace imstk
{
class AbstractDataArray;

class ImageData : public PointSet
{
public:
    ImageData() = default;
    ~ImageData() override = default;

    IMSTK_TYPE_NAME(ImageData)

    
    void print() const override;

    double getVolume() override;

    const Vec3i& getDimensions() const { return m_dims; }

    int getNumComponents() const { return m_numComps; }

    void* getVoidPointer();

    inline size_t getScalarIndex(int x, int y, int z = 0) { return getScalarIndex(x, y, z, m_dims, m_numComps); }
    inline size_t getScalarIndex(const Vec3i& imgCoord) { return getScalarIndex(imgCoord[0], imgCoord[1], imgCoord[2], m_dims, m_numComps); }

    inline static size_t getScalarIndex(int x, int y, int z, const Vec3i& dims, int numComps) { return (x + dims[0] * (y + z * dims[1])) * numComps; }

    std::shared_ptr<ImageData> cast(ScalarTypeId type);

    const Vec3d& getInvSpacing() const { return m_invSpacing; }

    const ScalarTypeId getScalarType() const;

    const Vec6d& getBounds()
    {
        const Vec3d size = Vec3d(
            m_spacing.x() * m_dims[0],
            m_spacing.y() * m_dims[1],
            m_spacing.z() * m_dims[2]);

        m_bounds[0] = m_origin.x();
        m_bounds[1] = m_origin.x() + size.x();
        m_bounds[2] = m_origin.y();
        m_bounds[3] = m_origin.y() + size.y();
        m_bounds[4] = m_origin.z();
        m_bounds[5] = m_origin.z() + size.z();

        return m_bounds;
    }

    void computeBoundingBox(Vec3d& lowerCorner, Vec3d& upperCorner, const double imstkNotUsed(paddingPercent)) override
    {
        const Vec6d& bounds = getBounds();
        lowerCorner = Vec3d(bounds[0], bounds[2], bounds[4]);
        upperCorner = Vec3d(bounds[1], bounds[3], bounds[5]);
    }

    std::shared_ptr<AbstractDataArray> getScalars() const { return m_scalarArray; }
    void setScalars(std::shared_ptr<AbstractDataArray> scalars, const int numComps, int* dim);

    const Vec3d& getOrigin() const { return m_origin; }
    void setOrigin(const Vec3d& origin) { m_origin = origin; }

    const Vec3d& getSpacing() const { return m_spacing; }
    void setSpacing(const Vec3d& spacing)
    {
        m_spacing    = spacing;
        m_invSpacing = Vec3d(1.0 / spacing[0], 1.0 / spacing[1], 1.0 / spacing[2]);
    }


    void allocate(const ScalarTypeId type, const int numComps, const Vec3i& dims, const Vec3d& spacing = Vec3d(1.0, 1.0, 1.0), const Vec3d& origin = Vec3d(0.0, 0.0, 0.0));

    void computePoints();

    void clear() override;

    std::unique_ptr<ImageData> clone()
    {
        return std::unique_ptr<ImageData>(cloneImplementation());
    }

private:
    // ImageData does not use transform, consider splitting into separate class
    using Geometry::translate;
    using Geometry::rotate;
    using Geometry::scale;
    using Geometry::transform;
    using Geometry::setRotation;
    using Geometry::setScaling;
    using Geometry::setTranslation;
    using Geometry::setTransform;

protected:
    std::shared_ptr<AbstractDataArray> m_scalarArray = nullptr;
    Vec3i m_dims       = Vec3i(0, 0, 0);
    int   m_numComps   = 1;
    Vec3d m_origin     = Vec3d(0.0, 0.0, 0.0);
    Vec3d m_spacing    = Vec3d(1.0, 1.0, 1.0);
    Vec3d m_invSpacing = Vec3d(1.0, 1.0, 1.0);
    Vec6d m_bounds     = Vec6d::Zero();

private:
    ImageData* cloneImplementation() const;
};
} // namespace imstk