cadenas píxel desde la codificación de longitud de ejecución

Question

He estado golpeando mi cabeza durante mucho tiempo en este

Estoy haciendo imágenes. Hasta ahora he digitalizan mis imágenes, lo que significa que a partir de una imagen en escala de grises, cada píxel debajo de un cierto valor se eliminan. Esto me da sólo en algunas regiones de la imagen original con una gran cantidad de "cero píxeles" de todo esas regiones.

longitud

A continuación me he encontrado mis codifica regiones en las "manchas". Carreras son un método de compresión de datos. Por ejemplo, supongamos que usted ha binarizada una plaza, la que tendrá sólo unas pocas carreras que describen la imagen completa. Las pistas están definidos por coordenadas x, y y una longitud.

Cuando recrear la imagen, para cada ejecución, ir a la coordenada x, y y añadir píxeles en el eje x para la longitud de la carrera.

Ahora tengo que tomar las carreras y crear una cadena de ella que describa el contorno de la región. No sé cómo hacer eso.

I tener un montón de X, Y, pistas de longitud y tengo que "navegar" alrededor de los bordes para formar un cadena . Normalmente en este proceso de formación de imágenes se realiza con la imagen original, pero no puedo usar la imagen original más aquí así que tengo que calcular con las carreras.

Sé que esto parece un gran muro de texto, pero no sé cómo hacer esta pregunta mejor.

¿Alguna pista o punteros sobre la aplicación idéntica sería impresionante.

editar

Gracias a relajarse, Illinois enlazar unas pocas imágenes:

_{(fuente: tudelft.nl )}

En este ejemplo, procesar la imagen B en el contorno C (que llamo cadena). Sin embargo, me gustaría para generar el contorno de D, de gestión Longitudes

Answer 1

Bien perdí ese contrato, pero la respuesta fue utilizar el Freeman Chain técnica de codificación

El hecho de que se ejecute la codificación de longitudes no tiene nada que ver con el algoritmo, al contrario que yo pensaba.

Answer 2

A primera vista no veo un algoritmo práctico para eso. La solución de un hombre pobre sería expanda de la imagen original de la longitud codificada uno. Así que si sus líneas de aspecto:

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

donde los caracteres de retorno del valor real de píxeles (por ejemplo, A = 0, B = 127, ...). Se puede escribir los valores de los píxeles en una matriz de dos dimensiones (u otra estructura de datos de su elección) .Se ve así:

ABBBAAAAAAAAAACDDDDDDDD
CDDDDAAACCCCCCAAAAAAAAA

Después de generar su cadena, eliminar la matriz y mantener la información de la cadena. Seguro que esto es caro, así tal vez que podría hacer esto antes de longitud que codifica la imagen original.

Answer 3

Aquí hay una solución muy simple y práctico (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;
        }
    }

}

Esto funciona iterando sobre las pistas, las pruebas de los puntos extremos izquierdo y derecho de la dirección que están saltando a, y añadiendo el número apropiado de elementos de cadena a dos vectores: uno en orden hacia adelante, para el lado derecho, y uno en orden inverso, para la izquierda. A continuación, conecta las dos cadenas mediante la adición de la cantidad apropiada de enlaces para la última línea de exploración, a continuación, invierte la cadena lateral a la izquierda y lo anexa a la correcta para producir la cadena final.

Hope esto es lo que está buscando!