Cluster.hpp

Go to the documentation of this file.

 
 
#pragma once
 
#include <algorithm>
#include <iostream>
#include <limits>
#include <string>
#include <type_traits>
#include <utility>
#include <vector>
 
#include "NumCpp/Core/Internal/Error.hpp"
#include "NumCpp/Core/Internal/StaticAsserts.hpp"
#include "NumCpp/Core/Internal/StlAlgorithms.hpp"
#include "NumCpp/Core/Types.hpp"
#include "NumCpp/ImageProcessing/Pixel.hpp"
#include "NumCpp/Utils/num2str.hpp"
 
namespace nc::imageProcessing
{
    //================================================================================
    // Class Description:
    template<typename dtype>
    class Cluster
    {
    private:
        STATIC_ASSERT_ARITHMETIC(dtype);
 
    public:
        //================================Typedefs===============================
        using const_iterator = typename std::vector<Pixel<dtype>>::const_iterator;
        using accumulator_t  = typename std::conditional<std::is_integral<dtype>::value, int64, double>::type;
 
        //=============================================================================
        // Description:
        Cluster() = default;
 
        //=============================================================================
        // Description:
        explicit Cluster(uint32 inClusterId) noexcept :
            clusterId_(inClusterId)
        {
        }
 
        //=============================================================================
        // Description:
        bool operator==(const Cluster<dtype>& rhs) const noexcept
        {
            if (pixels_.size() != rhs.pixels_.size())
            {
                return false;
            }
 
            return stl_algorithms::equal(begin(), end(), rhs.begin());
        }
 
        //=============================================================================
        // Description:
        bool operator!=(const Cluster<dtype>& rhs) const noexcept
        {
            return !(*this == rhs);
        }
 
        //=============================================================================
        // Description:
        const Pixel<dtype>& operator[](uint32 inIndex) const noexcept
        {
            return pixels_[inIndex];
        }
 
        //=============================================================================
        // Description:
        [[nodiscard]] const Pixel<dtype>& at(uint32 inIndex) const
        {
            if (inIndex >= pixels_.size())
            {
                THROW_INVALID_ARGUMENT_ERROR("index exceeds cluster size.");
            }
            return pixels_[inIndex];
        }
 
        //=============================================================================
        // Description:
        [[nodiscard]] const_iterator begin() const noexcept
        {
            return pixels_.cbegin();
        }
 
        //=============================================================================
        // Description:
        [[nodiscard]] const_iterator end() const noexcept
        {
            return pixels_.cend();
        }
 
        //=============================================================================
        // Description:
        [[nodiscard]] uint32 size() const noexcept
        {
            return static_cast<uint32>(pixels_.size());
        }
 
        //=============================================================================
        // Description:
        [[nodiscard]] uint32 clusterId() const noexcept
        {
            return clusterId_;
        }
 
        //=============================================================================
        // Description:
        [[nodiscard]] uint32 rowMin() const noexcept
        {
            return rowMin_;
        }
 
        //=============================================================================
        // Description:
        [[nodiscard]] uint32 rowMax() const noexcept
        {
            return rowMax_;
        }
 
        //=============================================================================
        // Description:
        [[nodiscard]] uint32 colMin() const noexcept
        {
            return colMin_;
        }
 
        //=============================================================================
        // Description:
        [[nodiscard]] uint32 colMax() const noexcept
        {
            return colMax_;
        }
 
        //=============================================================================
        // Description:
        [[nodiscard]] uint32 height() const noexcept
        {
            return rowMax_ - rowMin_ + 1;
        }
 
        //=============================================================================
        // Description:
        [[nodiscard]] uint32 width() const noexcept
        {
            return colMax_ - colMin_ + 1;
        }
 
        //=============================================================================
        // Description:
        [[nodiscard]] accumulator_t intensity() const noexcept
        {
            return intensity_;
        }
 
        //=============================================================================
        // Description:
        [[nodiscard]] dtype peakPixelIntensity() const noexcept
        {
            return peakPixelIntensity_;
        }
 
        //=============================================================================
        // Description:
        [[nodiscard]] double eod() const noexcept
        {
            return eod_;
        }
 
        //=============================================================================
        // Description:
        void addPixel(const Pixel<dtype>& inPixel)
        {
            pixels_.push_back(inPixel);
            intensity_ += static_cast<accumulator_t>(inPixel.intensity);
 
            // adjust the cluster bounds
            rowMin_             = std::min(rowMin_, inPixel.row);
            rowMax_             = std::max(rowMax_, inPixel.row);
            colMin_             = std::min(colMin_, inPixel.col);
            colMax_             = std::max(colMax_, inPixel.col);
            peakPixelIntensity_ = std::max(peakPixelIntensity_, inPixel.intensity);
 
            // calculate the energy on detector estimate
            eod_ = static_cast<double>(peakPixelIntensity_) / static_cast<double>(intensity_);
        }
 
        //=============================================================================
        // Description:
        [[nodiscard]] std::string str() const
        {
            std::string out;
            uint32      counter = 0;
            std::for_each(begin(),
                          end(),
                          [&](const Pixel<dtype>& pixel)
                          { out += "Pixel " + utils::num2str(counter++) + ":" + pixel.str(); });
 
            return out;
        }
 
        //============================================================================
        void print() const
        {
            std::cout << *this;
        }
 
        //=============================================================================
        // Description:
        friend std::ostream& operator<<(std::ostream& inStream, const Cluster<dtype>& inCluster)
        {
            inStream << inCluster.str();
            return inStream;
        }
 
    private:
        //================================Attributes===============================
        int32 clusterId_{ -1 };
        std::vector<Pixel<dtype>> pixels_{};
        uint32 rowMin_{ std::numeric_limits<uint32>::max() }; // largest possible number
        uint32 rowMax_{ 0 };
        uint32 colMin_{ std::numeric_limits<uint32>::max() }; // largest possible number
        uint32 colMax_{ 0 };
        accumulator_t intensity_{ 0 };
        dtype peakPixelIntensity_{ 0 };
        dtype minPixel{};
        dtype maxPixel{};
        double eod_{ 1. };
    };
} // namespace nc::imageProcessing