ndarray_utils.h

Go to the documentation of this file.

/******************************************************************************
 * Copyright 2014 Micah C Chambers (micahc.vt@gmail.com)
 *
 * NPL is free software: you can redistribute it and/or modify it under the
 * terms of the BSD 2-Clause License available in LICENSE or at
 * http://opensource.org/licenses/BSD-2-Clause
 *
 * @file ndarray_utils.h
 * @brief This file contains common functions which are useful for processing
 * of N-dimensional arrays and their derived counterparts (MRImage for
 * example). All of these functions return pointers to NDArray types, however
 * if an image is passed in, then the output will also be an image, you just
 * need to cast the output using dPtrCast<MRImage>(out).
 * mrimage_utils.h is for more specific image-processing algorithm, this if for
 * generally data of any dimension, without regard to orientation.
 ******************************************************************************/

#ifndef NDARRAY_UTILS_H
#define NDARRAY_UTILS_H

#include "ndarray.h"
#include "npltypes.h"
#include "basic_functions.h"

#include <Eigen/Dense>
#include <memory>
#include <list>
#include <unordered_set>

namespace npl {

using std::vector;

std::unordered_set<int64_t> getLabels(ptr<const NDArray> in);

bool comparable(const NDArray* left, const NDArray* right,
        bool* elL = NULL, bool* elR = NULL);

/*************************
 * Basic Kernel Functions
 *************************/

ptr<NDArray> derivative(ptr<const NDArray> in);

ptr<NDArray> derivative(ptr<const NDArray> in, size_t dir);

ptr<NDArray> dilate(ptr<NDArray> in, size_t reps);

ptr<NDArray> erode(ptr<NDArray> in, size_t reps);


void gaussianSmooth1D(ptr<NDArray> inout, size_t dim, double stddev);

/********************
 * Image Shifting
 ********************/

void shiftImageKern(ptr<NDArray> inout, size_t dd, double dist,
        double(*kern)(double,double) = npl::lanczosKern);

void shiftImageFFT(ptr<NDArray> inout, size_t dim, double dist,
        double(*window)(double,double) = npl::sincWindow);


/********************
 * Image Shearing
 ********************/

void shearImageKern(ptr<NDArray> inout, size_t dim, size_t len,
    double* dist, double(*kern)(double,double) = npl::lanczosKern);

void shearImageFFT(ptr<NDArray> inout, size_t dim, size_t len, double* dist,
        double(*window)(double,double) = npl::sincWindow);

int shearDecompose(std::list<Eigen::Matrix3d>& bestshears,
    double Rx, double Ry, double Rz, double stepx=1, double stepy=1, double stepz=1);

int shearTest(double Rx, double Ry, double Rz, double sx=0, double sy=0, double sz=0);

ptr<NDArray> linearRotate(double rx, double ry, double rz,
        ptr<const NDArray> in);

/********************
 * Image Rotating
 ********************/

void rotateImageKern(ptr<NDArray> inout, double rx, double ry, double rz);

int rotateImageShearKern(ptr<NDArray> inout, double rx, double ry, double rz,
        double(*kern)(double,double) = npl::lanczosKern);

int rotateImageShearFFT(ptr<NDArray> inout, double rx, double ry, double rz,
        double(*window)(double,double) = npl::sincWindow);

/****************************
 * Radial Fourier Transforms
 ****************************/

ptr<NDArray> pseudoPolar(ptr<const NDArray> in, size_t prdim);

std::vector<ptr<NDArray>> pseudoPolar(ptr<const NDArray> in);

ptr<NDArray> pseudoPolarZoom(ptr<const NDArray> inimg,
    size_t prdim);

void fillCircle(ptr<NDArray> inout, double radius, double alpha);

void fillLinear(ptr<NDArray> inout);

void fillZero(ptr<NDArray> inout);

void fillGaussian(ptr<NDArray> inout);

ptr<NDArray> concat(const vector<ptr<NDArray>>& images, size_t dir);

ptr<NDArray> concatElevate(const vector<ptr<NDArray>>& images);

ptr<NDArray> sobelEdge(ptr<const NDArray> img);

ptr<NDArray> collapseSum(ptr<const NDArray> img, size_t dim, bool doabs=false);


ptr<NDArray> relabelConnected(ptr<NDArray> input);

double otsuThresh(ptr<const NDArray> in);

void binarizeIP(ptr<NDArray> in, double t);

ptr<NDArray> binarize(ptr<const NDArray> in, double t);

ptr<NDArray> threshold(ptr<const NDArray> in, double t);

void thresholdIP(ptr<NDArray> in, double t);

ptr<NDArray> histEqualize(ptr<const NDArray> in);

/*************************************************
 * Image/Array Comparisons
 *************************************************/

double mse(ptr<const NDArray> a, ptr<const NDArray> b,
        ptr<const NDArray> mask = NULL);

double dice(ptr<const NDArray> a, ptr<const NDArray> b, ptr<const NDArray> mask);

double corr(ptr<const NDArray> a, ptr<const NDArray> b,
        ptr<const NDArray> mask = NULL);

double information(ptr<const NDArray> a, ptr<const NDArray> b,
        int bins = 100, int krad = 4, Metric m = METRIC_MI,
        ptr<const NDArray> mask = NULL);

ptr<NDArray> medianFilter(ptr<const NDArray> img);

void standardizeIP(ptr<NDArray> img);

ptr<NDArray> standardize(ptr<const NDArray> img);

ptr<NDArray> varianceT(ptr<const NDArray> img);

ptr<NDArray> createRandLabels(ptr<const NDArray> example, size_t nlabels, double sd);

void normalizeTS(ptr<NDArray> inout);

} // npl
#endif  //NDARRAY_UTILS_H