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

def adjust_gamma(image, gamma=1.0):
    invGamma = 1.0 / gamma
    table = np.array([((i / 255.0) ** invGamma) * 255
            for i in np.arange(0, 256)]).astype("uint8")
    
    return cv2.LUT(image, table)

def unsharp_mask(image, kernel_size=(13, 13), sigma=1.0, amount=2.5, threshold=10):
    """Return a sharpened version of the image, using an unsharp mask."""
    blurred = cv2.GaussianBlur(image, kernel_size, sigma)
    sharpened = float(amount + 1) * image - float(amount) * blurred
    sharpened = np.maximum(sharpened, np.zeros(sharpened.shape))
    sharpened = np.minimum(sharpened, 255 * np.ones(sharpened.shape))
    sharpened = sharpened.round().astype(np.uint8)
    if threshold > 0:
        low_contrast_mask = np.absolute(image - blurred) < threshold
        np.copyto(sharpened, image, where=low_contrast_mask)
        
    return sharpened

def find_orientation(cont):
    m = cv2.moments(cont, True)
    cen_x = m['m10'] / m['m00']
    cen_y = m['m01'] / m['m00']

    m_11 = 2*m['m11'] - m['m00'] * (cen_x*cen_x+cen_y*cen_y)
    m_02 = m['m02'] - m['m00'] * cen_y*cen_y
    m_20 = m['m20'] - m['m00'] * cen_x*cen_x

    theta = 0 if m_20==m_02 else atan2(m_11, m_20-m_02)/2.0
    theta = theta * 180 / pi

    return (cen_x, cen_y, theta)

def rotate_image(img, angles):
    height, width = img.shape[:2]
    
    rotation_matrix = cv2.getRotationMatrix2D((width/2, height/2), angles, 1)
    rotated_image = cv2.warpAffine(img, rotation_matrix, (width,height))

    return rotated_image


img = cv2.imread('gear1.jpg')

resized_img = imutils.resize(img, width=540)
height, width = resized_img.shape[:2]

gamma_adjusted = adjust_gamma(resized_img, 2.5)
sharp = unsharp_mask(gamma_adjusted)
gray = cv2.cvtColor(sharp, cv2.COLOR_BGR2GRAY)
gauss_blur = cv2.GaussianBlur(gray, (13,13), 2.5)
ret, thresh = cv2.threshold(gauss_blur, 250, 255, cv2.THRESH_BINARY+cv2.THRESH_OTSU)

kernel = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (3,3))
thresh = cv2.morphologyEx(thresh, cv2.MORPH_DILATE, kernel, iterations=2)

kernel = np.ones((3,3), np.uint8)
thresh = cv2.morphologyEx(thresh, cv2.MORPH_OPEN, kernel, iterations=2)

contours = cv2.findContours(thresh.copy(), cv2.RETR_EXTERNAL,
                            cv2.CHAIN_APPROX_SIMPLE)[0]

cen_x, cen_y, theta = find_orientation(contours[0])

reference_angle = -24.14141919602858
rot_angle = 0.0
if theta < reference_angle:
    rot_angle = -(theta - reference_angle)
else:
    rot_angle = (reference_angle - theta)

rot_img = rotate_image(resized_img, rot_angle)

reference image gear1 gear2

क्या कोई मुझे बता सकता है कि मैं कहाँ गलत हो गया? किसी भी सहायता की सराहना की जाएगी।

1
jemish mavani 21 अगस्त 2020, 17:51

1 उत्तर

सबसे बढ़िया उत्तर

गियर और होल का बिनराइजेशन आसान लगता है। आपको छिद्रों को शोर और अतिरिक्त छोटी विशेषताओं से अलग करने में सक्षम होना चाहिए।

पहले ज्यामितीय केंद्र का पता लगाएं, और केंद्र के चारों ओर के कोणों के अनुसार छेदों को क्रमबद्ध करें। छिद्रों के क्षेत्रों की भी गणना करें। फिर आप चक्रीय तरीके से छेदों को मॉडल से मिलाने का प्रयास कर सकते हैं। 20 छेद हैं, और आपको केवल 20 पदों का परीक्षण करने की आवश्यकता है। आप कोणों और क्षेत्रों में अंतर के कुछ संयोजन द्वारा मिलान को रेट कर सकते हैं। सबसे अच्छा मैच आपको अभिविन्यास बताता है।

यह बहुत विश्वसनीय होना चाहिए।

आप प्रति छेद औसत त्रुटि की गणना करके और उस मान को रद्द करने के लिए सुधार करके कोण का एक बहुत सटीक मान प्राप्त कर सकते हैं (यह कम से कम वर्ग फिटिंग के बराबर है)।

2
Yves Daoust 21 अगस्त 2020, 16:38