利用OpenCV+ConvNets检测几何图形

1
重磅干货，第一时间送达

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
#detect checkbox/square
def extract_quads(self,image_arr,name_arr):


    if len(image_arr) > 0:


        for index,original_image in enumerate(image_arr):


            #to store extracted images
            extracted_quad = []
            image = original_image.copy()          


            #grayscale only if its not already
            if len(image.shape) > 2:
                gray = cv2.cvtColor(image.copy(), cv2.COLOR_BGR2GRAY)  
            else:
                gray = image.copy()


            #image preprocessing for quadrilaterals
            img_dilate = self.do_quad_imageprocessing(gray,self.blocksize,self.thresh_const,self.kernelsize)   


            if len(img_dilate) > 0:


                try:
                    #detect contours
                    cnts = cv2.findContours(img_dilate.copy(), cv2.RETR_LIST, cv2.CHAIN_APPROX_SIMPLE)
                    cnts = imutils.grab_contours(cnts)


                    #loop through detected contours
                    for c in cnts:
                        peri = cv2.arcLength(c, True)
                        approx = cv2.approxPolyDP(c, (self.epsilon)* peri, True)


                        #bounding rec cordinates
                        (x, y, w, h) = cv2.boundingRect(approx)


                        #get the aspect ratio
                        aspectratio = float(w/h)
                        area = cv2.contourArea(c) 
                        if area < self.rec_max_area and area > self.rec_min_area and (aspectratio >= self.aspect_ratio[0] and aspectratio <= self.aspect_ratio[1]):


                            #check if there are 4 corners in the polygon
                            if len(approx) == 4:                 
                                cv2.drawContours(original_image,[c], 0, (0,255,0), 2)
                                roi = original_image[y:y+h, x:x+w]
                                extracted_quad.append(roi)


                except Exception as e:
                    print('The following exception occured during quad shape detection: ',e)


            self.extracted_img_data.append([original_image,extracted_quad,name_arr[index]])


    else:            
        print('No image is found during the extraction process')

1
2
3
4
5
6
7
8
9
10
11
12
13
def Img2Pdf(dirname):
    
    images = []
    
    #get the pdf file
    for x in os.listdir(dirname):
        if (dirname.split('.')[1]) == 'pdf':
            pdf_filename = x
            images_from_path = convert_from_path(os.path.join(dirname),dpi=300, poppler_path = r'C:Program Files (x86)poppler-0.68.0_x86poppler-0.68.0bin')
for image in images_from_path:
                images.append(np.array(image))
                
    return images

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
#keras things
from keras.utils import to_categorical
from keras import layers
from keras import models
from keras.regularizers import l2




Y_test_orig = to_categorical(Y_test_orig, num_classes=2) 
Y_train_orig = to_categorical(Y_train_orig, num_classes=2)


# 3 layer ConvNet
model = models.Sequential()
model.add(layers.Conv2D(32, (3, 3), activation='relu',input_shape=(32,32,1)))
model.add(layers.MaxPooling2D((2, 2)))


model.add(layers.Conv2D(64, (3, 3), activation='relu'))
model.add(layers.MaxPooling2D((2, 2)))


model.add(layers.Conv2D(128, (3, 3), activation='relu'))
model.add(layers.MaxPooling2D((2, 2)))


#dense layer
model.add(layers.Flatten())


#add the regulizer
model.add(layers.Dense(128, activation='linear', activity_regularizer=l2(0.0003)))
model.add(layers.Dense(128, activation='relu'))
model.add(layers.Dense(2, activation='sigmoid'))  


model.summary()


from keras.optimizers import Adam
opt = Adam(lr=0.001)
model.compile(optimizer=opt, loss=keras.losses.categorical_crossentropy, metrics=['accuracy'])


ntrain = len(X_train_orig)
nval = len(X_test_orig)
X_train_orig = X_train_orig.reshape((len(X_train_orig),32,32,1)) 
X_test_orig = X_test_orig.reshape((len(X_test_orig),32,32,1))


train_datagen = ImageDataGenerator(rescale = 1./255,rotation_range = 40, width_shift_range = .2,
                                  height_shift_range = .2, shear_range = .2, zoom_range =  .2, horizontal_flip = True)


val_datagen = ImageDataGenerator(rescale = 1./255)


train_generator = train_datagen.flow(X_train_orig,Y_train_orig,batch_size=32)
val_generator = val_datagen.flow(X_test_orig,Y_test_orig,batch_size = 32)




#X_train_orig, X_test_orig, Y_train_orig,Y_test_orig
history = model.fit_generator(train_generator,steps_per_epoch = ntrain/32, epochs = 64, validation_data = val_generator, validation_steps = nval/32  )