Detección de línea | Detección de ángulo con Java

Question

Estoy procesando algunas imágenes que mi UGV (Vehichle terrestre no tripulado) captura para hacer que se mueva en una línea.

Quiero obtener el ángulo de esa línea en función del horizonte. Voy a tratar de explicar con algunos ejemplos:

La imagen superior haría que mi UGV para mantener en línea recta, ya que el ángulo es de unos 90 grados. Pero la siguiente haría girar a la izquierda, como el ángulo comparadas con el horizonte redondea sobre 120.

pude transformar con éxito esas imágenes en la imagen de abajo usando otsu de umbral:

y también se utiliza un algoritmo de detección de bordes para conseguir esto:

Pero estoy atascado en este momento tratando de encontrar un algoritmo que detecs los bordes/líneas y salidas - o me ayuda a la salida - el ángulo de dicha línea ..

Answer 1

Aquí está mi intento usando ImageJ:

// Open the Image 
ImagePlus image = new ImagePlus(filename); 

    // Make the Image 8 bit 
IJ.run(image, "8-bit", ""); 

    // Apply a Threshold (0 - 50) 
ByteProcessor tempBP = (ByteProcessor)image.getProcessor(); 
tempBP.setThreshold(0, 50, 0); 
IJ.run(image, "Convert to Mask", ""); 

    // Analyze the Particles 
ParticleAnalyzer pa = new ParticleAnalyzer(
    ParticleAnalyzer.SHOW_MASKS + 
    ParticleAnalyzer.IN_SITU_SHOW, 
    1023 + 
    ParticleAnalyzer.ELLIPSE 
    , rt, 0.0, 999999999, 0, 0.5); 

IJ.run(image, "Set Measurements...", "bounding fit redirect=None decimal=3"); 

pa.analyze(image); 

int k = 0; 
double maxSize = -1; 
for (int i = 0; i < rt.getCounter(); i ++) { 
    // Determine creteria for best oval. 
    // The major axis should be much longer than the minor axis. 
    // let k = best oval 
} 
double bx = rt.getValue("BX", k); 
double by = rt.getValue("BY", k); 
double width = rt.getValue("Width", k); 
double height = rt.getValue("Height", k); 

// Your angle: 
double angle = rt.getValue("Angle", k); 
double majorAxis = rt.getValue("Major", k); 
double minorAxis = rt.getValue("Minor", k); 

¿Cómo funciona el código:

1. hacer que la imagen en escala de grises.
2. Aplica un umbral para obtener solo las áreas oscuras. Esto supone que las líneas siempre estarán cerca del negro.
3. Aplique un Analizador de partículas para encontrar elipses en la imagen.
4. Pasa por las "Partículas" para encontrar las que se ajusten a nuestros criterios.
5. Obtén el ángulo de nuestra partícula.

He aquí un ejemplo de lo que la imagen se ve como cuando lo analizo:

NOTA: El código no se ha probado. Acabo de convertir lo que hice en Visual ImageJ en Java.