catene pixel da run-length encoding

Question

Sono stato sbattere la testa per molto tempo su questo

sto facendo imaging. Finora ho binarizzate mie immagini, il che significa che da un'immagine in scala di grigi, ogni pixel sotto un certo valore vengono eliminate. Questo mi dà solo alcune regioni su l'immagine originale con un sacco di "zero pixel" in tutto quelle regioni.

lunghezza

Avanti Ho eseguito codificato le mie regioni in "blob". Funzionamenti sono un metodo di compressione dei dati. Per esempio, supponiamo che avete binarizzata una piazza, la si avrà solo un paio di basi che descrivono l'intera immagine. Le piste sono definiti da coordinate x, y ed una lunghezza.

Quando ricreare l'immagine, per ogni corsa, vai a coordinate x, y e aggiungere pixel sull'asse x per la lunghezza della corsa.

Ora devo prendere le piste e creare una catena di fuori di esso che descrivere il profilo della regione. Non so come fare.

ho un mazzo di x, y, dalle piste di lunghezza e devo "navigare" intorno ai bordi per formare un catena . Normalmente in immagini questo processo è fatto con l'immagine originale, ma non è possibile utilizzare l'immagine originale più qui quindi devo calcolare con le piste.

So che questo sembra un grande muro di testo, ma non so come porre questa domanda migliore.

Eventuali suggerimenti o puntatori sull'attuazione identici sarebbe terribile.

Modifica

grazie per rilassarsi, Ill collegare alcune immagini:

_{(fonte: tudelft.nl )}

In questo esempio, si elaborare l'immagine B nel contorno C (che chiamo catena). Comunque mi piacerebbe per generare il contorno da D, la tirature

Answer 1

Beh ho perso quel contratto, ma la risposta è stata di utilizzare il Freeman catena tecnica di codifica

Il fatto che è gestito codifica lunghezze non ha nulla a che fare con l'algoritmo, a differenza che in precedenza pensato.

Answer 2

A prima vista non vedo un algoritmo pratico per questo. La soluzione di un uomo povero sarebbe espandere l'immagine originale dalla lunghezza codificato uno. Quindi, se le linee simile a questa:

A 3B 10A C 8D
C 4D 3A 6C 9A

dove i personaggi restituiscono il valore reale del pixel (ad esempio A = 0, B = 127, ...). Si potrebbe scrivere i valori dei pixel in una matrice bidimensionale (o un'altra datastructure di vostra scelta) .Si è simile al seguente:

ABBBAAAAAAAAAACDDDDDDDD
CDDDDAAACCCCCCAAAAAAAAA

In seguito generare la catena, eliminare l'array e conservare le informazioni sulla catena. Certo questo è così costoso forse si potrebbe fare questo prima di lunghezza-codifica l'immagine originale.

Answer 3

Ecco una soluzione perfettamente semplice e pratica (C ++):

#include <iostream>
#include <vector>

struct Run { int x, w; };
enum { EAST, NORTHEAST, NORTH, NORTHWEST, WEST, SOUTHWEST, SOUTH, SOUTHEAST };

int main() {

    const Run data[] = {
        { 7, 2 },
        { 5, 6 },
        { 5, 7 },
        { 5, 7 },
        { 6, 6 },
        { 0, 12 },
        { 0, 12 },
        { 0, 11 },
        { 1, 7 },
        { 3, 4 },
        { 3, 4 },
        { 3, 5 },
        { 3, 7 },
        { 3, 7 },
        { 5, 5 }
    };

    std::vector<Run> runs(data, data + 15);
    std::vector<int> before;
    std::vector<int> after;
    unsigned int i;
    int j;

    for (i = 0; i < runs.size() - 1; ++i) {

        if (runs[i].x < runs[i + 1].x) {

            for (j = 0; j < runs[i + 1].x - runs[i].x - 1; ++j)
                before.push_back(WEST);
            before.push_back(NORTHWEST);

        } else if (runs[i].x > runs[i + 1].x) {

            before.push_back(NORTHEAST);
            for (j = 0; j < runs[i].x - runs[i + 1].x - 1; ++j)
                before.push_back(EAST);

        } else {

            before.push_back(NORTH);

        }

        int first_right(runs[i].x + runs[i].w);
        int second_right(runs[i + 1].x + runs[i + 1].w);

        if (first_right < second_right) {

            after.push_back(SOUTHEAST);
            for (j = 0; j < second_right - first_right - 1; ++j)
                after.push_back(EAST);

        } else if (first_right > second_right) {

            for (j = 0; j < first_right - second_right - 1; ++j)
                after.push_back(WEST);
            after.push_back(SOUTHWEST);

        } else {

            after.push_back(SOUTH);

        }

    }

    for (j = 0; j < runs.back().w - 1; ++j)
        after.push_back(WEST);

    std::reverse(before.begin(), before.end());
    after.insert(after.end(), before.begin(), before.end());

    for (j = 0; j < int(after.size()); ++j) {
        switch (after[j]) {
        case EAST:      std::cout << "EAST\n";      break;
        case NORTHEAST: std::cout << "NORTHEAST\n"; break;
        case NORTH:     std::cout << "NORTH\n";     break;
        case NORTHWEST: std::cout << "NORTHWEST\n"; break;
        case WEST:      std::cout << "WEST\n";      break;
        case SOUTHWEST: std::cout << "SOUTHWEST\n"; break;
        case SOUTH:     std::cout << "SOUTH\n";     break;
        case SOUTHEAST: std::cout << "SOUTHEAST\n"; break;
        }
    }

}

Questo funziona iterazione su piste, testare i punti finali sinistro e destro per la direzione che stanno saltando a, e aggiungendo il numero appropriato di elementi della catena a due vettori: uno, al fine in avanti, per il lato destro, e uno in ordine inverso, per la sinistra. Quindi esso collega le due catene aggiungendo il numero appropriato di collegamenti per l'ultima linea di scansione, quindi inverte la catena laterale sinistro e lo aggiunge a quella giusta per produrre la catena finale.

Spero che questo è quello che stai cercando!