python पायथन का उपयोग कर किसी छवि में एक लेज़र लाइन का पता लगाने के लिए




image numpy (3)

पायथन का उपयोग कर छवि में एक मोटे तौर पर क्षैतिज लाल लेजर लाइन का पता लगाने की सबसे विश्वसनीय विधि क्या है? मैं 3 डी लेजर स्कैनिंग से संबंधित एक छोटी परियोजना पर काम कर रहा हूं, और मुझे अपने विरूपण से दूरी की गणना के लिए एक छवि में लेजर का पता लगाने में सक्षम होना चाहिए।

शुरू करने के लिए, मेरे पास दो छवियां हैं, एक संदर्भ छवि कोई लेज़र लाइन नहीं है, और एक छवि बी जो निश्चित रूप से एक लेजर लाइन, संभवतः विकृत है जैसे

नमूना छवि ए:

नमूना छवि B:

चूंकि ये आरजीबी हैं, लेकिन लेजर लाल है, मैं इस फ़ंक्शन का उपयोग करके नीले और हरे रंग के चैनलों को निकालकर कुछ शोर निकाल देता हूं:

from PIL import Image
import numpy as np

def only_red(im):
    """
    Strips out everything except red.
    """
    data = np.array(im)
    red, green, blue, alpha = data.T
    im2 = Image.fromarray(red.T)
    return im2

यह मुझे इन छवियों को प्राप्त करता है:

इसके बाद, मैं PIL.ImageChops.difference() का उपयोग करके इन दो छवियों के अंतर को लेकर अधिक शोर का प्रयास करता हूं और इसे खत्म कर देता PIL.ImageChops.difference()PIL.ImageChops.difference() । आदर्श रूप से, दो छवियों के बीच के संपर्क समान होंगे, जिससे अंतर को लेजर लाइन को छोड़कर कुछ भी नहीं हो सकता है। दुर्भाग्य से, क्योंकि लेजर प्रकाश को जोड़ता है, प्रत्येक छवि का एक्सपोज़र और समग्र चमक काफी अलग है, जिसके परिणामस्वरूप अंतर अभी भी काफी शोर है। जैसे

मेरा आखिरी चरण है कि "सबसे अच्छा अनुमान" कहां है जहां रेखा है। चूंकि मुझे पता है कि रेखा मोटे तौर पर क्षैतिज होगी और लेजर लाइन को छवि में प्रतिभाशाली चीज की जानी चाहिए, मैं प्रत्येक स्तंभ को स्कैन करता हूं और पंक्ति को चमकीले पिक्सेल के साथ ढूंढता हूं, जिसे मैं लेजर लाइन मानता हूं। इसके लिए कोड है:

import os
from PIL import Image, ImageOps
import numpy as np

x = Image.open('laser-diff.png', 'r')
x = x.convert('L')

out = Image.new("L", x.size, "black")
pix = out.load()

y = np.asarray(x.getdata(), dtype=np.float64).reshape((x.size[1], x.size[0]))
print y.shape
for col_i in xrange(y.shape[1]):
    col_max = max([(y[row_i][col_i], row_i) for row_i in xrange(y.shape[0])])
    col_max_brightness, col_max_row = col_max
    print col_i, col_max
    pix[col_i, col_max_row] = 255

out.save('laser-line.png')

मुझे वास्तव में मेरी दूरी गणना करने की आवश्यकता है col_max मूल्यों की सरणी है, लेकिन laser-line.png मुझे सफलता की कल्पना करने में मदद करता है, और ऐसा दिखता है:

जैसा कि आप देख सकते हैं, अनुमान बहुत करीब है, लेकिन इसमें कुछ शोर भी है, जो कि ज्यादातर छवि के बाईं तरफ जहां लेज़र लाइन को मैट ब्लैक फ़ॉंस्ट द्वारा अवशोषित किया जाता है।

मेरी सटीकता और / या गति में सुधार करने के लिए मैं क्या कर सकता हूं? मैं रास्पबेरी पीए जैसी एआरएम प्लेटफॉर्म पर इसे चलाने की कोशिश कर रहा हूं, इसलिए मैं चिंतित हूं कि मेरा कोड अच्छी तरह से चलाने के लिए बहुत ही अक्षम हो सकता है।

मैं नम्पी के मैट्रिक्स फ़ंक्शंस से पूरी तरह से परिचित नहीं हूं, इसलिए मुझे लूप के लिए धीमी गति से निपटना पड़ा ताकि प्रत्येक कॉलम को स्कैन करने के बजाय कुछ ज्यादा कुशल हो सके। नम्पी में प्रति स्तंभ प्रतिभाशाली पिक्सेल के साथ पंक्ति को खोजने का एक तेज़ तरीका है?

इसके अलावा, लेजर लाइन को बिना किसी अंतर के प्रदर्शन करने से पहले छवियों को बराबर करने का एक विश्वसनीय तरीका है?


सबसे पहले आप शायद अपनी नकारात्मक छवि की तीव्रता को अपने सकारात्मक से घटाकर अधिक शोर हटाने के लिए पहले से बचा सकते हैं। उदाहरण के लिए शायद औसत intesity के अनुपात द्वारा rescaling एक अच्छा पहली कोशिश हो सकती है?

आप एक थ्रेशोल्ड डालने का भी प्रयास कर सकते हैं: यदि आपका सबसे अच्छा मूल्य नीचे है, तो शायद यह आपके लेजर नहीं बल्कि एक शोर बिंदु है ...

तो हाँ, numpy सबसे अच्छी पंक्ति / कर्नल को argmax फ़ंक्शन के साथ मिल सकता है।


पहले रंग दर्ज करें जो कि लेजर है और केवल लाल रंग (इस मामले में) छोड़ देता है। फिर एक ही प्रभाव लागू करें और परिणाम की जांच करें।

इस मामले में, आपके पास बहुत कम प्रदूषित परिणाम होगा। परिणाम

दरवाजे पर लाल का विश्लेषण करने में समस्या का सामना करना पड़ता है, जो खो गया है।


मैंने कुछ करने की कोशिश की मुझे नहीं लगता कि यह पूरी तरह से मजबूत है लेकिन आपके उदाहरण पर यह अपेक्षाकृत अच्छी तरह से काम करता है।

मैं अपने "अंतर" छवि में किनारे का पता लगाने के लिए भयानक बढ़त का पता लगाया और फिर इस ट्यूटोरियल के रूप में होफ़ लाइन को लागू किया गया। इसलिए मैंने आपकी संसाधित छवि से शुरू किया (यह कि मैं कोड में lineDetection.jpg को कॉल करता हूं)।

यहाँ अंतिम स्क्रिप्ट है

import cv2
import numpy as np

img = cv2.imread('lineDetection.jpg')
gray = cv2.cvtColor(img,cv2.COLOR_BGR2GRAY)
edges = cv2.Canny(gray,10,100)
minLineLength = 50
maxLineGap = 20
lines = cv2.HoughLinesP(edges,0.05,np.pi/5000,10,minLineLength,maxLineGap)
print(len(lines))
for i in range(len(lines)):
    x1,y1,x2,y2 = lines[i][0]
    cv2.line(img,(x1,y1),(x2,y2),(0,255,0),2)

cv2.imwrite('houghlines5.jpg',img)

संसाधित छवि पर ग्रीन लाइन का पता लगाया गया। (आप इसे अच्छे प्रभाव के लिए मूल छवि में जोड़ सकते हैं)

आशा करता हूँ की ये काम करेगा।





image-processing