use crate::image::{GenericImage, Luma};
use crate::raster2::index_iter::SizeForIndex;
use crate::raster2::roi::{RasterRoi, RoiOverlap};
use crate::raster2::roi_mask::RoiMask;
use crate::raster2::{Point2I, RasterMask};
use faer::prelude::default;
use imageproc::definitions::Image;
pub use imageproc::region_labelling::Connectivity;
use imageproc::region_labelling::connected_components;
pub struct Region<'a> {
labeled_regions: &'a LabeledRegions,
label: u32,
roi: RasterRoi,
count: usize,
}
impl<'a> Region<'a> {
pub fn create_roi_mask(&self, padding: u32) -> RoiMask {
let height = self.roi.extent().y as u32 + 2 * padding;
let width = self.roi.extent().x as u32 + 2 * padding;
let mut mask = RasterMask::empty(width, height);
let mask_roi = self.roi.expanded(padding);
let overlay = RoiOverlap::new(mask_roi, self.roi);
for p in overlay.iter_intersection_a() {
if self.label == self.labeled_regions.label_at(p.parent) {
mask.set_point(p.local, true).unwrap();
}
}
RoiMask::new_resized(mask, self.roi, mask_roi)
}
}
impl<'a> Region<'a> {
pub fn label(&self) -> u32 {
self.label
}
pub fn roi(&self) -> &RasterRoi {
&self.roi
}
pub fn count(&self) -> usize {
self.count
}
}
#[derive(Clone)]
pub struct LabeledRegions {
buffer: Image<Luma<u32>>,
raw_roi: Vec<RasterRoi>,
raw_counts: Vec<usize>,
}
impl LabeledRegions {
pub fn buffer(&self) -> &Image<Luma<u32>> {
&self.buffer
}
pub fn label_at(&self, p: Point2I) -> u32 {
if p.x < 0
|| p.y < 0
|| p.x >= self.buffer.width() as i32
|| p.y >= self.buffer.height() as i32
{
return 0; }
self.buffer.get_pixel(p.x as u32, p.y as u32)[0]
}
pub fn get_region(&self, label: u32) -> Option<Region<'_>> {
if label == 0 || label as usize >= self.raw_roi.len() {
return None; }
let roi = &self.raw_roi[label as usize];
let count = self.raw_counts[label as usize];
Some(Region {
labeled_regions: self,
label,
roi: *roi,
count,
})
}
pub fn iter(&self) -> RegionIterator<'_> {
RegionIterator {
labeled: self,
current: 1, }
}
pub fn region_count(&self) -> usize {
self.raw_roi.len() - 1 }
pub fn from_connected<I>(image: &I, conn: Connectivity, background: I::Pixel) -> Self
where
I: GenericImage,
I::Pixel: Eq,
{
let result = connected_components(image, conn, background);
let mut raw_regions: Vec<RasterRoi> = Vec::new();
let mut raw_counts: Vec<usize> = Vec::new();
for i in result.iter_indices() {
let vi = result.get_pixel(i.x as u32, i.y as u32)[0] as usize;
if vi == 0 {
continue;
}
while raw_regions.len() <= vi {
raw_regions.push(default());
raw_counts.push(0);
}
raw_regions[vi].expand_to_contain(i);
raw_counts[vi] += 1;
}
Self {
buffer: result,
raw_roi: raw_regions,
raw_counts,
}
}
}
pub struct RegionIterator<'a> {
labeled: &'a LabeledRegions,
current: usize,
}
impl<'a> Iterator for RegionIterator<'a> {
type Item = Region<'a>;
fn next(&mut self) -> Option<Self::Item> {
let label = self.current as u32;
self.current += 1;
self.labeled.get_region(label)
}
}