ClusterMaker.hpp

Go to the documentation of this file.

 
 
#pragma once
 
#include <algorithm>
#include <cmath>
#include <set>
#include <string>
#include <utility>
#include <vector>
 
#include "NumCpp/Core/Internal/Error.hpp"
#include "NumCpp/Core/Internal/StaticAsserts.hpp"
#include "NumCpp/Core/Types.hpp"
#include "NumCpp/ImageProcessing/Cluster.hpp"
#include "NumCpp/NdArray.hpp"
 
namespace nc::imageProcessing
{
    //=============================================================================
    // Class Description:
    template<typename dtype>
    class ClusterMaker
    {
    private:
        STATIC_ASSERT_ARITHMETIC(dtype);
 
    public:
        //================================Typedefs=====================================
        using const_iterator = typename std::vector<Cluster<dtype>>::const_iterator;
 
        //=============================================================================
        // Description:
        ClusterMaker(const NdArray<bool>* const  inXcdArrayPtr,
                     const NdArray<dtype>* const inIntensityArrayPtr,
                     uint8                       inBorderWidth = 0) :
            xcds_(inXcdArrayPtr),
            intensities_(inIntensityArrayPtr)
        {
            if (xcds_->shape() != intensities_->shape())
            {
                THROW_INVALID_ARGUMENT_ERROR("input xcd and intensity arrays must be the same shape.");
            }
 
            shape_ = xcds_->shape();
 
            // convert the NdArray of booleans to a vector of exceedances
            for (uint32 row = 0; row < shape_.rows; ++row)
            {
                for (uint32 col = 0; col < shape_.cols; ++col)
                {
                    if (xcds_->operator()(row, col))
                    {
                        const Pixel<dtype> thePixel(row, col, intensities_->operator()(row, col));
                        xcdsVec_.push_back(thePixel);
                    }
                }
            }
 
            runClusterMaker();
 
            for (uint8 i = 0; i < inBorderWidth; ++i)
            {
                expandClusters();
            }
        }
 
        //=============================================================================
        // Description:
        uint32 size() noexcept
        {
            return static_cast<uint32>(clusters_.size());
        }
 
        //=============================================================================
        // Description:
        const Cluster<dtype>& operator[](uint32 inIndex) const noexcept
        {
            return clusters_[inIndex];
        }
 
        //=============================================================================
        // Description:
        [[nodiscard]] const Cluster<dtype>& at(uint32 inIndex) const
        {
            if (inIndex >= clusters_.size())
            {
                THROW_INVALID_ARGUMENT_ERROR("index exceeds cluster size.");
            }
            return clusters_[inIndex];
        }
 
        //=============================================================================
        // Description:
        [[nodiscard]] const_iterator begin() const noexcept
        {
            return clusters_.cbegin();
        }
 
        //=============================================================================
        // Description:
        [[nodiscard]] const_iterator end() const noexcept
        {
            return clusters_.cend();
        }
 
    private:
        //==================================Attributes=================================
        const NdArray<bool>* const  xcds_{};
        const NdArray<dtype>* const intensities_{};
        std::vector<Pixel<dtype>>   xcdsVec_{};
 
        Shape shape_{};
 
        std::vector<Cluster<dtype>> clusters_{};
 
        //=============================================================================
        // Description:
        Pixel<dtype> makePixel(int32 inRow, int32 inCol) noexcept
        {
            // Make sure that on the edges after i've added or subtracted 1 from the row and col that
            // i haven't gone over the edge
            const uint32 row       = std::min(static_cast<uint32>(std::max<int32>(inRow, 0)), shape_.rows - 1);
            const uint32 col       = std::min(static_cast<uint32>(std::max<int32>(inCol, 0)), shape_.cols - 1);
            const dtype  intensity = intensities_->operator()(row, col);
 
            return Pixel<dtype>(row, col, intensity);
        }
 
        //=============================================================================
        // Description:
        void findNeighbors(const Pixel<dtype>& inPixel, std::set<Pixel<dtype>>& outNeighbors)
        {
            // using a set will auto take care of adding duplicate pixels on the edges
 
            // the 8 surrounding neighbors
            const auto row = static_cast<int32>(inPixel.row);
            const auto col = static_cast<int32>(inPixel.col);
 
            outNeighbors.insert(outNeighbors.end(), makePixel(row - 1, col - 1));
            outNeighbors.insert(outNeighbors.end(), makePixel(row - 1, col));
            outNeighbors.insert(outNeighbors.end(), makePixel(row - 1, col + 1));
            outNeighbors.insert(outNeighbors.end(), makePixel(row, col - 1));
            outNeighbors.insert(outNeighbors.end(), makePixel(row, col + 1));
            outNeighbors.insert(outNeighbors.end(), makePixel(row + 1, col - 1));
            outNeighbors.insert(outNeighbors.end(), makePixel(row + 1, col));
            outNeighbors.insert(outNeighbors.end(), makePixel(row + 1, col + 1));
        }
 
        //=============================================================================
        // Description:
        void findNeighborNotXcds(const Pixel<dtype>& inPixel, std::vector<Pixel<dtype>>& outNeighbors)
        {
            std::set<Pixel<dtype>> neighbors;
            findNeighbors(inPixel, neighbors);
 
            // check if the neighboring pixels are exceedances and insert into the xcd vector
            for (auto& pixel : neighbors)
            {
                if (!xcds_->operator()(pixel.row, pixel.col))
                {
                    outNeighbors.push_back(pixel);
                }
            }
        }
 
        //=============================================================================
        // Description:
        void findNeighborXcds(const Pixel<dtype>& inPixel, std::vector<uint32>& outNeighbors)
        {
            std::set<Pixel<dtype>> neighbors;
            findNeighbors(inPixel, neighbors);
            std::vector<Pixel<dtype>> neighborXcds;
 
            // check if the neighboring pixels are exceedances and insert into the xcd vector
            for (auto& pixel : neighbors)
            {
                if (xcds_->operator()(pixel.row, pixel.col))
                {
                    neighborXcds.push_back(pixel);
                }
            }
 
            // loop through the neighbors and find the cooresponding index into exceedances_
            for (auto& pixel : neighborXcds)
            {
                auto theExceedanceIter = std::find(xcdsVec_.begin(), xcdsVec_.end(), pixel);
                outNeighbors.push_back(static_cast<uint32>(theExceedanceIter - xcdsVec_.begin()));
            }
        }
 
        //=============================================================================
        // Description:
        void runClusterMaker()
        {
            uint32 clusterId = 0;
 
            for (auto& currentPixel : xcdsVec_)
            {
                // not already visited
                if (currentPixel.clusterId == -1)
                {
                    Cluster<dtype> newCluster(clusterId); // a new cluster
                    currentPixel.clusterId = clusterId;
                    newCluster.addPixel(currentPixel); // assign pixel to cluster
 
                    // get the neighbors
                    std::vector<uint32> neighborIds;
                    findNeighborXcds(currentPixel, neighborIds);
                    if (neighborIds.empty())
                    {
                        clusters_.push_back(newCluster);
                        ++clusterId;
                        continue;
                    }
 
                    // loop through the neighbors
                    for (uint32 neighborsIdx = 0; neighborsIdx < neighborIds.size(); ++neighborsIdx)
                    {
                        Pixel<dtype>& currentNeighborPixel = xcdsVec_[neighborIds[neighborsIdx]];
 
                        // go to neighbors
                        std::vector<uint32> newNeighborIds;
                        findNeighborXcds(currentNeighborPixel, newNeighborIds);
 
                        // loop through the new neighbors and add them to neighbors
                        for (auto newNeighborId : newNeighborIds)
                        {
                            // not already in neighbors
                            if (std::find(neighborIds.begin(), neighborIds.end(), newNeighborId) == neighborIds.end())
                            {
                                neighborIds.push_back(newNeighborId);
                            }
                        }
 
                        // not already assigned to a cluster
                        if (currentNeighborPixel.clusterId == -1)
                        {
                            currentNeighborPixel.clusterId = clusterId;
                            newCluster.addPixel(currentNeighborPixel);
                        }
                    }
 
                    clusters_.push_back(std::move(newCluster));
                    ++clusterId;
                }
            }
        }
 
        //=============================================================================
        // Description:
        void expandClusters()
        {
            // loop through the clusters
            for (auto& theCluster : clusters_)
            {
                // loop through the pixels of the cluster
                for (auto& thePixel : theCluster)
                {
                    std::vector<Pixel<dtype>> neighborsNotXcds;
                    findNeighborNotXcds(thePixel, neighborsNotXcds);
 
                    // loop through the neighbors and if they haven't already been added to the cluster, add them
                    for (auto& newPixel : neighborsNotXcds)
                    {
                        if (std::find(theCluster.begin(), theCluster.end(), newPixel) == theCluster.end())
                        {
                            theCluster.addPixel(newPixel);
                        }
                    }
                }
            }
        }
    };
} // namespace nc::imageProcessing