Libs/Image/Image.h

Namespaces

Name
shapeworks User usage reporting (telemetry)

Classes

	Name
class	shapeworks::Image

Source code

```cpp

pragma once

include

include "Region.h"

include "Shapeworks.h"

namespace shapeworks {

class Mesh;

class Image { public: enum InterpolationType { Linear, NearestNeighbor };

using PixelType = float; using ImageType = itk::Image; using StatsPtr = itk::StatisticsImageFilter::Pointer; using ImageIterator = itk::ImageRegionIterator; using InterpolatorType = itk::LinearInterpolateImageFunction;

// constructors and assignment operators // explicit Image(const Dims dims); explicit Image(const std::string& pathname) : itk_image_(read(pathname)) {} explicit Image(ImageType::Pointer imagePtr) : itk_image_(imagePtr) { if (!itk_image_) throw std::invalid_argument("null imagePtr"); } explicit Image(const vtkSmartPointer vtkImage);

Image(Image&& img) : itk_image_(nullptr) { this->itk_image_.Swap(img.itk_image_); } Image(const Image& img) : itk_image_(cloneData(img.itk_image_)) {} Image& operator=(const Image& img);
Image& operator=(Image&& img);

operator ImageType::Pointer() { return itk_image_; } ImageType::Pointer getITKImage() const { return itk_image_; }

vtkSmartPointer getVTKImage() const;

// modification functions //

Image& operator-();

Image operator+(const Image& other) const; Image& operator+=(const Image& other);

Image operator-(const Image& other) const; Image& operator-=(const Image& other);

Image operator*(const Image& other) const;

Image operator(const PixelType x) const; Image& operator=(const PixelType x);

Image operator/(const PixelType x) const; Image& operator/=(const PixelType x);

Image operator+(const PixelType x) const; Image& operator+=(const PixelType x);

Image operator-(const PixelType x) const; Image& operator-=(const PixelType x);

Image& antialias(unsigned iterations = 50, double maxRMSErr = 0.01f, int layers = 3);

Image& recenter();

Image& resample(const TransformPtr transform, const Point3 origin, const Dims dims, const Vector3 spacing, const ImageType::DirectionType direction, InterpolationType interp = NearestNeighbor);

Image& resample(const Vector& physicalSpacing, InterpolationType interp = Linear);

Image& resample(double isoSpacing = 1.0, InterpolationType interp = Linear);

Image& resize(Dims logicalDims, InterpolationType interp = Linear);

Image& pad(int padding, PixelType value = 0.0);

Image& pad(int padx, int pady, int padz, PixelType value = 0.0);

Image& pad(IndexRegion& region, PixelType value = 0.0);

Image& translate(const Vector3& v);

Image& scale(const Vector3& v);

Image& rotate(const double angle, const Vector3& axis);

Image& rotate(const double angle, Axis axis);

TransformPtr createCenterOfMassTransform();

TransformPtr createRigidRegistrationTransform(const Image& target_dt, float isoValue = 0.0, unsigned iterations = 20);

Image& applyTransform(const TransformPtr transform, InterpolationType interp = Linear);

Image& applyTransform(const TransformPtr transform, const Point3 origin, const Dims dims, const Vector3 spacing, const ImageType::DirectionType direction, InterpolationType interp = NearestNeighbor);

Image& applyTransform(const TransformPtr transform, const Image& referenceImage, InterpolationType interp = Linear);

Image& extractLabel(const PixelType label = 1.0);

Image& closeHoles(const PixelType foreground = 0.0);

Image& binarize(PixelType minVal = 0.0, PixelType maxVal = std::numeric_limits::max(), PixelType innerVal = 1.0, PixelType outerVal = 0.0);

Image& computeDT(PixelType isoValue = 0.0);

Image& applyCurvatureFilter(unsigned iterations = 10);

Image& applyGradientFilter();

Image& applySigmoidFilter(double alpha = 10.0, double beta = 10.0);

Image& applyTPLevelSetFilter(const Image& featureImage, double scaling = 20.0);

Image& topologyPreservingSmooth(float scaling = 20.0, float sigmoidAlpha = 10.5, float sigmoidBeta = 10.0);

Image& applyIntensityFilter(double minVal, double maxVal);

Image& gaussianBlur(double sigma = 0.0);

Image& crop(PhysicalRegion region, const int padding = 0);

Image& fitRegion(PhysicalRegion region, const PixelType value = 0.0);

Image& clip(const Plane plane, const PixelType val = 0.0);

Image& reflect(const Axis& axis);

Image& setOrigin(Point3 origin = Point3({0, 0, 0}));

Image& setSpacing(Vector3 spacing);

Image& setCoordsys(ImageType::DirectionType coordsys);

Image& isolate();

// query functions //

Dims dims() const { return itk_image_->GetLargestPossibleRegion().GetSize(); }

Point3 size() const { return toPoint(spacing()) * toPoint(dims()); }

double get_largest_dimension_size() const;

Vector spacing() const { return itk_image_->GetSpacing(); }

double get_minimum_spacing() const;

Point3 origin() const { return itk_image_->GetOrigin(); }

Point3 center() const { return origin() + size() / 2.0; }

ImageType::DirectionType coordsys() const { return itk_image_->GetDirection(); };

Point3 centerOfMass(PixelType minVal = 0.0, PixelType maxVal = 1.0) const;

PixelType min();

PixelType max();

PixelType mean();

PixelType std();

IndexRegion logicalBoundingBox() const;

PhysicalRegion physicalBoundingBox() const;

PhysicalRegion physicalBoundingBox(PixelType isovalue) const;

PhysicalRegion logicalToPhysical(IndexRegion region) const;

IndexRegion physicalToLogical(PhysicalRegion region) const;

Point3 logicalToPhysical(const Coord& c) const;

Coord physicalToLogical(const Point3& p) const;

bool isInside(const Point3& p) const;

ImageIterator iterator();

bool compare(const Image& other, bool verifyall = true, double tolerance = 0.0, double precision = 1e-6) const;

bool operator==(const Image& other) const { return compare(other); }

// export functions //

Image& write(const std::string& filename, bool compressed = true);

Mesh toMesh(PixelType isovalue) const;

Image::PixelType evaluate(Point p);

void paintSphere(Point p, double radius, PixelType value);

void paintCircle(Point p, double radius, unsigned int axis, PixelType value);

bool isPainted() const { return painted_; }

Image& fill(PixelType value);

bool isDistanceTransform() const;

static std::vector getSupportedTypes() { return {"nrrd", "nii", "nii.gz", "mhd", "tiff", "jpeg", "jpg", "png", "dcm", "ima"}; }

static bool isSupportedType(const std::string& filename) { for (const auto& type : Image::getSupportedTypes()) { if (StringUtils::hasSuffix(filename, type)) { return true; } } return false; }

private: friend struct SharedCommandData; Image() : itk_image_(nullptr) { } // only for use by SharedCommandData since an Image should always be valid, never "empty"

static ImageType::Pointer read(const std::string& filename); static ImageType::Pointer readDICOMImage(const std::string& pathname);

static ImageType::Pointer cloneData(const ImageType::Pointer img);

static vtkSmartPointer getPolyData(const Image& image, PixelType isoValue = 0.0);

Image& pad(Dims lowerExtendRegion, Dims upperExtendRegion, PixelType value = 0.0);

StatsPtr statsFilter() const;

ImageType::Pointer itk_image_;

bool painted_ = false;

InterpolatorType::Pointer interpolator_; };

std::ostream& operator<<(std::ostream& os, const Image& img);

template <> Image operator(const Image& img, const double x); template <> Image operator/(const Image& img, const double x); template <> Image& operator=(Image& img, const double x); template <> Image& operator/=(Image& img, const double x);

} // namespace shapeworks ```

Updated on 2026-03-31 at 16:02:11 +0000