/
CORS.py
148 lines (115 loc) · 4.33 KB
/
CORS.py
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
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
import numpy as np
import cv2
# from cvutil.basicf import *
# from cvutil.filter import *
import matplotlib.pyplot as plt
from CORS_utils import *
def intensity(bgr_img):
"""Return intensity image computed by (R+G+B)/3. Used with color_opponency as an intensity channel."""
if np.ndim(bgr_img) != 3:
raise ValueError('bgr_img must be BGR image (3 dimensions), not ' + str(np.ndim(bgr_img)))
img_b, img_g, img_r = cv2.split(bgr_img.astype(np.float))
imgray = (img_b+img_g+img_r)/3.0
#imgray = cv2.cvtColor(bgr_img, cv2.COLOR_BGR2GRAY).astype(np.float)
return imgray
def color_opponency(bgr_img):
"""Return tuple of color opponency from BGR color image(in format: [RG,GR,BY,YB])"""
if np.ndim(bgr_img) != 3:
raise ValueError('bgr_img must be BGR image (3 dimensions), not ' + str(np.ndim(bgr_img)))
img_b, img_g, img_r = cv2.split(bgr_img.astype(np.float))
fimg_R = NoNegative(img_r - (img_g+img_b)/2.0)
fimg_G = NoNegative(img_g - (img_r+img_b)/2.0)
fimg_B = NoNegative(img_b - (img_r+img_g)/2.0)
fimg_Y = NoNegative((img_r+img_g)/2.0 - np.abs(img_r-img_g)/2.0 - img_b)
fimg_RG = NoNegative(fimg_R-fimg_G)
fimg_GR = NoNegative(fimg_G-fimg_R)
fimg_BY = NoNegative(fimg_B-fimg_Y)
fimg_YB = NoNegative(fimg_Y-fimg_B)
return [fimg_RG, fimg_GR, fimg_BY, fimg_YB]
def LocalFigureNorm(src,figureRatio=0.2):
"""
Subtract src from boxFilter version of itself, with radius 0.2 of its side.
Parameters:
==========
- figureRatio is approximated figure's size compared to src's width.
"""
h,w = src.shape[:2]
th,tw = int(h*figureRatio), int(w*figureRatio)
figApprx = cv2.boxFilter(src, -1, (tw,tw))
return WNorm(MinMaxNorm(NoNegative(src-figApprx)))
def WNorm(src):
"""Divide by sqrt of number of local maxima, e.g. too promote few local peaks"""
peaks = local_maxima(src, 3)
if len(peaks)==0:
return src
else:
return src/float(np.sqrt(len(peaks)))
def OnOffFM(i_gpyr):
"""On,off center-surround intensity maps"""
onpyr = []
offpyr = []
for i in xrange(0,len(i_gpyr)): # scale 2,3,4
curi = i_gpyr[i]
surround3 = cv2.boxFilter(curi, -1, (7,7))
surround7 = cv2.boxFilter(curi, -1, (15,15))
on3 = NoNegative(curi - surround3)
on7 = NoNegative(curi - surround7)
off3 = NoNegative(surround3 - curi)
off7 = NoNegative(surround7 - curi)
onpyr.append(on3+on7)
offpyr.append(off3+off7)
onmap = AcrossScaleAddition(onpyr)
offmap = AcrossScaleAddition(offpyr)
return onmap, offmap
def saliency_map(imbgr,GaussR=9):
"""
Compute corner saliency maps.
Parameters:
-----------
- imbgr is input BGR colour image.
- cornerForFigure is true for saliency map generation
(e.g. take log and exhibit more corners to cue figures)
- if false, will not take log, and show less, but more accurate corner locations.
"""
imbgr = resize_image(imbgr, 256)
# R,G,B,Y
colops = color_opponency(imbgr)
# intensity
imgray = intensity(imbgr)
colors = ApplyEach(colops,laplacian_pyramid,[2])
Ion,Ioff = OnOffFM(gaussian_pyramid(imgray,2))
# all channels (r,g,b,y,i_on,i_off) feature maps
lpyrs = [l1 for l1,l2 in colors] + [Ion,Ioff]
edgepyrs = ApplyEach(lpyrs, complex_cells_response, [Gbs_r,Gbs_im])
mul_f = lambda x,y: x*y
log_f = lambda x: np.log(x+1)
# Corner Feature:
# Extract corner features by multiply all orientations together,
# thus leaves with only locations with multiple orientations.
# --> take log on corner response to show more corner, to better cue figure locations
cornermaps = [log_f(reduce(mul_f, edgepyrs[i])) for i in xrange(len(edgepyrs))]
# make corner maps all channels comparable e.g. range (0,1)
cornermaps = ApplyEach(cornermaps, MinMaxNorm)
# suppress too abundance corner informations
cornermaps = ApplyEach(cornermaps, LocalFigureNorm, [0.2])
# combine all "figure cues"
cornermap = sum(cornermaps)
cornermap = resize_image(cornermap, 128)
cornermap = cv2.GaussianBlur(cornermap, (GaussR,GaussR), 0,0 )
return cornermap
def prepare_gabor_kernels():
global Gbs_r, Gbs_im, OrientedGaussianKernels
Gbs_r, Gbs_im = get_simple_cell_style_gabor_kernels(frequency=0.2, nOrientations=4)
print('Gabor set up.'),
if __name__ == '__main__':
prepare_gabor_kernels()
imbgr = cv2.imread('1.jpg')
salmap = saliency_map(imbgr)
plt.figure()
plt.subplot(1,2,1)
plt.imshow(cv2.cvtColor(imbgr,cv2.COLOR_BGR2RGB))
plt.title('input')
plt.subplot(1,2,2)
plt.imshow(salmap)
plt.title('saliency map')
plt.show()