Collaboration diagram for Node:

Public Member Functions
	Node (int32_t id, std::unique_ptr< std::vector< RGBXY > > &pixels)

XY	centroid () const

ImageLib::RGBPixel< uint8_t >	color () const

std::array< int32_t, 4 >	bounding_box_xywh () const

std::array< int, 4 >	create_binary_image (std::vector< uint8_t > &binary) const

void	clear_contour ()

void	compute_contour ()

int32_t	id () const

size_t	area () const

const std::set< Node_ptr > &	edges () const

size_t	num_edges () const

const std::vector< RGBXY > &	get_pixels () const

ColoredContours &	get_contours ()

void	add_pixels (const std::vector< RGBXY > &new_pixels)

void	add_edge_pixel (const XY edge_pixel)

void	clear_edge_pixels ()

void	clear_all ()

void	add_edge (const Node_ptr &node)

void	remove_edge (const Node_ptr &node)

void	remove_all_edges ()

Public Attributes
ColoredContours	m_contours

Protected Attributes
int32_t	m_id

std::unique_ptr< std::vector< RGBXY > >	m_pixels

std::set< Node_ptr >	m_edges {}

std::set< XY >	m_edge_pixels {}

Detailed Description

Definition at line 65 of file node.h.

Constructor & Destructor Documentation

◆ Node()

Node::Node	(	int32_t	id,
		std::unique_ptr< std::vector< RGBXY > > &	pixels
	)

inline

Definition at line 76 of file node.h.

77 : m_id(id), m_pixels(std::move(pixels)) {

78 }

Member Function Documentation

◆ add_edge()

void Node::add_edge ( const Node_ptr & node )

inline

Definition at line 119 of file node.h.

                                               {
        m_edges.insert(node);
    }

◆ add_edge_pixel()

void Node::add_edge_pixel ( const XY edge_pixel )

Definition at line 170 of file node.cpp.

                                             {
    m_edge_pixels.insert(edge_pixel);
}

◆ add_pixels()

void Node::add_pixels ( const std::vector< RGBXY > & new_pixels )

Definition at line 164 of file node.cpp.

                                                        {
    for (auto &c : new_pixels) {
        m_pixels->push_back(c);
    }
}

◆ area()

size_t Node::area ( ) const

inline

Definition at line 96 of file node.h.

                               {
        return m_pixels->size();
    };

◆ bounding_box_xywh()

std::array< int32_t, 4 > Node::bounding_box_xywh ( ) const

Definition at line 54 of file node.cpp.

                                                   {
    if (m_pixels->empty()) {
        return {0, 0, 0, 0};
    }
 
    int32_t x_min{INT_MAX};
    int32_t y_min{INT_MAX};
    int32_t x_max{0};
    int32_t y_max{0};
    for (auto &[_, p] : *m_pixels) {
        if (p.x < x_min) {
            x_min = p.x;
        }
        if (p.x > x_max) {
            x_max = p.x;
        }
        if (p.y < y_min) {
            y_min = p.y;
        }
        if (p.y > y_max) {
            y_max = p.y;
        }
    }
 
    for (auto &p : m_edge_pixels) {
        if (p.x < x_min) {
            x_min = p.x;
        }
        if (p.x > x_max) {
            x_max = p.x;
        }
        if (p.y < y_min) {
            y_min = p.y;
        }
        if (p.y > y_max) {
            y_max = p.y;
        }
    }
 
    const int32_t w{x_max - x_min + 1};
    const int32_t h{y_max - y_min + 1};
 
    return std::array<int32_t, 4>{x_min, y_min, w, h};
}

◆ centroid()

XY Node::centroid ( ) const

Definition at line 9 of file node.cpp.

                        {
    XY centroid{0, 0};
    const int32_t m_pixels_size{static_cast<int32_t>(m_pixels->size())};
 
    // Guard against division by zero after loop
    if (m_pixels_size == 0) {
        return centroid;
    }
 
    for (auto &[_, pos] : *m_pixels) {
        centroid.x += pos.x;
        centroid.y += pos.y;
    }
 
    centroid.x /= m_pixels_size;
    centroid.y /= m_pixels_size;
 
    return centroid;
}

◆ clear_all()

void Node::clear_all ( )

Definition at line 178 of file node.cpp.

                     {
    m_edges.clear();
    m_pixels->clear();
    m_edge_pixels.clear();
}

◆ clear_contour()

void Node::clear_contour ( void )

Definition at line 120 of file node.cpp.

                             {
    m_contours.contours.clear();
    m_contours.hierarchy.clear();
    m_contours.is_hole.clear();
    m_contours.colors.clear();
    m_contours.curves.clear();
}

◆ clear_edge_pixels()

void Node::clear_edge_pixels ( )

Definition at line 174 of file node.cpp.

                             {
    m_edge_pixels.clear();
}

◆ color()

ImageLib::RGBPixel< uint8_t > Node::color ( ) const

Definition at line 29 of file node.cpp.

                                            {
    const int32_t m_pixels_size{static_cast<int32_t>(m_pixels->size())};
 
    // Guard against division by zero after loop
    if (m_pixels_size == 0) {
        return {0, 0, 0};
    }
 
    float r{0};
    float g{0};
    float b{0};
    for (auto &[color, _] : *m_pixels) {
        r += color.red;
        g += color.green;
        b += color.blue;
    }
 
    r /= m_pixels_size;
    g /= m_pixels_size;
    b /= m_pixels_size;
 
    // Accept lossy conversion - the difference is very minimal
    return {static_cast<uint8_t>(r), static_cast<uint8_t>(g), static_cast<uint8_t>(b)};
}

◆ compute_contour()

void Node::compute_contour ( void )

Definition at line 128 of file node.cpp.

                               {
    // return list of all contours present in Node.
    // usually 1 sometimes more if holes are present
 
    clear_contour();
 
    std::vector<uint8_t> binary;
    std::array<int, 4> xywh{create_binary_image(binary)};
 
    int xmin = xywh[0];
    int ymin = xywh[1];
    int bw = xywh[2];
    int bh = xywh[3];
 
    ContoursResult contour_res = contours::find_contours(binary, bw, bh);
 
    for (size_t cidx = 0; cidx < contour_res.contours.size(); ++cidx) {
        auto &contour = contour_res.contours[cidx];
        for (auto &p : contour) {
            p.x += xmin;
            p.y += ymin;
        }
 
        // if (contour_res.is_hole[cidx]) { continue; }
 
        ImageLib::RGBPixel<uint8_t> _col = color();
        ImageLib::RGBAPixel<uint8_t> col{_col.red, _col.green, _col.blue, 255};
        m_contours.contours.push_back(contour);
        m_contours.hierarchy.push_back(contour_res.hierarchy[cidx]);
        m_contours.is_hole.push_back(contour_res.is_hole[cidx]);
        m_contours.colors.push_back(col);
    }
 
    m_contours.curves.resize(m_contours.contours.size());
}

◆ create_binary_image()

std::array< int, 4 > Node::create_binary_image ( std::vector< uint8_t > & binary ) const

Definition at line 99 of file node.cpp.

                                                                           {
    std::array<int, 4> xywh{bounding_box_xywh()};
 
    binary.resize(static_cast<size_t>(xywh[2]) * static_cast<size_t>(xywh[3]), 0);
 
    for (auto &[_, p] : *m_pixels) {
        int32_t _x = p.x - xywh[0];
        int32_t _y = p.y - xywh[1];
        binary[_y * xywh[2] + _x] = 1;
    }
 
    // include the edge pixels to ensure contour overlap with neighbor
    for (auto &p : m_edge_pixels) {
        int32_t _x = p.x - xywh[0];
        int32_t _y = p.y - xywh[1];
        binary[_y * xywh[2] + _x] = 1;
    }
 
    return xywh;
}

◆ edges()

const std::set< Node_ptr > & Node::edges ( ) const

inline

Definition at line 99 of file node.h.

                                                 {
        return m_edges;
    }

◆ get_contours()

ColoredContours & Node::get_contours ( )

inline

Definition at line 108 of file node.h.

                                           {
        return m_contours;
    }

◆ get_pixels()

const std::vector< RGBXY > & Node::get_pixels ( ) const

inline

Definition at line 105 of file node.h.

                                                      {
        return *m_pixels;
    }

◆ id()

int32_t Node::id ( ) const

inline

Definition at line 93 of file node.h.

                              {
        return m_id;
    };

◆ num_edges()

size_t Node::num_edges ( ) const

inline

Definition at line 102 of file node.h.

                                    {
        return m_edges.size();
    }

◆ remove_all_edges()

void Node::remove_all_edges ( )

inline

Definition at line 125 of file node.h.

                                   {
        m_edges.clear();
    }

◆ remove_edge()

void Node::remove_edge ( const Node_ptr & node )

inline

Definition at line 122 of file node.h.

                                                  {
        m_edges.erase(node);
    }

Member Data Documentation

◆ m_contours

ColoredContours Node::m_contours

Definition at line 88 of file node.h.

◆ m_edge_pixels

std::set<XY> Node::m_edge_pixels {}

protected

Definition at line 73 of file node.h.

73{};

◆ m_edges

std::set<Node_ptr> Node::m_edges {}

protected

Definition at line 69 of file node.h.

69{};

◆ m_id

int32_t Node::m_id

protected

Definition at line 67 of file node.h.

◆ m_pixels

std::unique_ptr<std::vector<RGBXY> > Node::m_pixels

protected

Definition at line 68 of file node.h.

The documentation for this class was generated from the following files:

include/internal/node.h
src/internal/node.cpp

Public Member Functions

Public Attributes

Protected Attributes

Detailed Description

Constructor & Destructor Documentation

◆ Node()

Member Function Documentation

◆ add_edge()

◆ add_edge_pixel()

◆ add_pixels()

◆ area()

◆ bounding_box_xywh()

◆ centroid()

◆ clear_all()

◆ clear_contour()

◆ clear_edge_pixels()

◆ color()

◆ compute_contour()

◆ create_binary_image()

◆ edges()

◆ get_contours()

◆ get_pixels()

◆ id()

◆ num_edges()

◆ remove_all_edges()

◆ remove_edge()

Member Data Documentation

◆ m_contours

◆ m_edge_pixels

◆ m_edges

◆ m_id

◆ m_pixels