OpenCV trovare scafo concava

Question

Ho una serie di punti discreti mostrati in un'immagine, come la seguente

Voglio ricostruire o da campionamento (non sono sicuro che cosa è il modo corretto per descriverlo) il immagine, in modo che l'immagine risultante sarebbe come la seguente . Non è necessario che sia esattamente uguale all'immagine di esempio, ma l'idea principale è quella di riempire quella originale.

Ho un'idea iniziale su come farlo. Ma non so come farlo dopo il primo passo. La mia idea è quella di separare prima l'immagine usando i kmea e scoprire i diversi oggetti. E l'ho fatto con successo. Le immagini risultanti dopo i kmean sono: .

Dopo kmean, voglio usare find findur o qualcosa di simile concavo per ottenere il contorno di queste forme e riempire la forma utilizzando funzioni come i buchi di riempimento. Tuttavia, ho trovato "trova contorno" non funziona, considererà ogni singolo pixel come un contorno.

L'altro modo in cui sto pensando è utilizzare l'interpolazione. Ma non sono sicuro se sia possibile con punti così scarsi. Qualcuno ha qualche idea su come farlo? Non sono sicuro se sono sulla strada giusta e sono aperto a qualsiasi soluzione.

Grazie mille!

Answer 1

Dai un'occhiata alle trasformazioni morfologiche. Vorrei iniziare con un'operazione di dilatazione utilizzando un kernel di grandi dimensioni, ad esempio MORPH_ELLIPSE con una dimensione (15,15). Successivamente, riduci le macchie usando l'operazione di erosione con lo stesso kernel di dimensioni. Dai uno sguardo ai documenti here. Nota che OpenCV offre anche operazioni morfologiche concatenate o sequenziate. Vedi here. Vedrai quindi che il mio suggerimento è un'operazione di "chiusura".

Aggiornamento: Ho sperimentato una semplice dilatazione e contornatura per ottenere i risultati mostrati nell'immagine. I risultati sembrano soddisfare i requisiti generali del problema.

Allo stesso modo, quale "tempo reale" significa per l'applicazione non è specificato, ma questo insieme di operazioni può essere eseguito rapidamente e potrebbe facilmente essere applicato a un'applicazione a 30 fps.

seguente snippet di codice:

// Convert image to grayscale 
cvtColor(src, gray, CV_BGR2GRAY); 
threshold(gray, gray, 128.0, 128.0, THRESH_BINARY); 

// Dilate to fill holes 
dilate(gray, dest, getStructuringElement(MORPH_ELLIPSE, Size(13,13))); 

// Find contours 
vector<vector<Point> > contours; 
vector<Vec4i> hierarchy; 
findContours(dest, contours, hierarchy, CV_RETR_TREE, CV_CHAIN_APPROX_SIMPLE, Point(0,0)); 

    // Prune contours 
    float maxArea = 0.0f; 
    for (size_t i = 0; i< contours.size(); i++) 
    { 
     if (contourArea(contours[i]) >= maxArea) 
     { 
      maxArea = contourArea(contours[i]); 
     } 
    } 

    float minArea = 0.20f * maxArea; 
    vector<vector<Point> > prunedContours; 
    for (size_t i = 0; i< contours.size(); i++) 
    { 
     if (contourArea(contours[i]) >= minArea) 
     { 
      prunedContours.push_back(contours[i]); 
     } 
    } 

// Smooth the contours 
vector<vector<Point> > smoothedContours; 
    smoothedContours.resize(prunedContours.size()); 
    for (size_t i=0;i<prunedContours.size();i++) 
    { 
    vector<float> x; 
    vector<float> y; 

    const size_t n = prunedContours[i].size(); 

    for (size_t j=0;j<n;j++) 
     { 
     x.push_back(prunedContours[i][j].x); 
     y.push_back(prunedContours[i][j].y); 
     } 

    Mat G; 
    transpose(getGaussianKernel(11,4.0,CV_32FC1),G); 

    vector<float> xSmooth; 
    vector<float> ySmooth; 

    filter2D(x,xSmooth, CV_32FC1, G); 
    filter2D(y,ySmooth, CV_32FC1, G); 

    for (size_t j=0;j<n;j++) 
     { 
     smoothedContours[i].push_back(Point2f(xSmooth[j],ySmooth[j])); 
     } 
    }