def compute_S_real_axis(GR, DR, Gsum):
# compute selfenergy from Marsiglio formula
B = -1.0 / pi * DR.imag[:, None, None] * ones([len(w), 2, 2])
GRloc = einsum('ab,wbc,cd->wad', tau3, sum(GR, axis=0), tau3)
return -g**2*dw/Nk*(conv(B, Gsum, ['z,w-z'], [0], [False])[:len(w)] \
-conv(B*(1+nB[:,None,None]), GRloc, ['z,w-z'], [0], [False])[:len(w)] \
+conv(B, GRloc*nF[:,None,None], ['z,w-z'], [0], [False])[:len(w)])
def compute_S_real_axis(GR, DR, Gsum):
# compute selfenergy from Marsiglio formula
B = -1.0 / pi * DR.imag[:, :, :, None, None] * ones([Nk, Nk, len(w), 2, 2])
tau3GRtau3 = einsum('ab,...bc,cd->...ad', tau3, GR, tau3)
return -g**2*dw/Nk**2*(conv(B, Gsum, ['k-q,q','k-q,q','z,w-z'], [0,1,2], [True,True,False])[:,:,:len(w)] \
- conv(B*(1+nB[None,None,:,None,None]), tau3GRtau3, ['k-q,q','k-q,q','z,w-z'], [0,1,2], [True,True,False])[:,:,:len(w)] \
+ conv(B, tau3GRtau3*nF[None,None,:,None,None], ['k-q,q','k-q,q','z,w-z'], [0,1,2], [True,True,False])[:,:,:len(w)])
def compute_GG(self, G):
out = np.zeros((self.nk, self.nk, self.ntau, 2, 2), dtype=complex)
Grev = -G[:, :, ::-1]
idxs = [(0, 0, 0, 0), (1, 0, 1, 0), (0, 1, 0, 1), (1, 1, 1, 1)]
for i, j, a, b in idxs:
out[:, :, :, 0, 0] += conv(G[:, :, :, i, j],
Grev[:, :, :, a, b], ['k,k+q', 'k,k+q'],
[0, 1], [True, True],
beta=self.beta)
idxs = [(0, 0, 1, 0), (1, 0, 0, 0), (0, 1, 1, 1), (1, 1, 0, 1)]
for i, j, a, b in idxs:
out[:, :, :, 0, 1] += conv(G[:, :, :, i, j],
Grev[:, :, :, a, b], ['k,k+q', 'k,k+q'],
[0, 1], [True, True],
beta=self.beta)
idxs = [(0, 0, 0, 1), (1, 0, 1, 1), (0, 1, 0, 0), (1, 1, 1, 0)]
for i, j, a, b in idxs:
out[:, :, :, 1, 0] += conv(G[:, :, :, i, j],
Grev[:, :, :, a, b], ['k,k+q', 'k,k+q'],
[0, 1], [True, True],
beta=self.beta)
idxs = [(0, 0, 1, 1), (1, 0, 0, 1), (0, 1, 1, 0), (1, 1, 0, 0)]
for i, j, a, b in idxs:
out[:, :, :, 1, 1] += conv(G[:, :, :, i, j],
Grev[:, :, :, a, b], ['k,k+q', 'k,k+q'],
[0, 1], [True, True],
beta=self.beta)
return -self.g0**2 / self.nk**2 * out
def compute_S(self, G, D):
#return -self.g0**2/self.nk**2 * conv(G, D, ['k-q,q','k-q,q'], [0,1], [True,True], beta=self.beta)
out = np.zeros((self.nk, self.nk, self.ntau, 2, 2), dtype=complex)
idxs = [(0, 0, 0, 0), (1, 0, 1, 0), (0, 1, 0, 1), (1, 1, 1, 1)]
for i, j, a, b in idxs:
out[:, :, :, 0, 0] += conv(G[:, :, :, i, j],
D[:, :, :, a, b], ['k-q,q', 'k-q,q'],
[0, 1], [True, True],
beta=self.beta)
idxs = [(0, 0, 1, 0), (1, 0, 0, 0), (0, 1, 1, 1), (1, 1, 0, 1)]
for i, j, a, b in idxs:
out[:, :, :, 0, 1] += conv(G[:, :, :, i, j],
D[:, :, :, a, b], ['k-q,q', 'k-q,q'],
[0, 1], [True, True],
beta=self.beta)
idxs = [(0, 0, 0, 1), (1, 0, 1, 1), (0, 1, 0, 0), (1, 1, 1, 0)]
for i, j, a, b in idxs:
out[:, :, :, 1, 0] += conv(G[:, :, :, i, j],
D[:, :, :, a, b], ['k-q,q', 'k-q,q'],
[0, 1], [True, True],
beta=self.beta)
idxs = [(0, 0, 1, 1), (1, 0, 0, 1), (0, 1, 1, 0), (1, 1, 0, 0)]
for i, j, a, b in idxs:
out[:, :, :, 1, 1] += conv(G[:, :, :, i, j],
D[:, :, :, a, b], ['k-q,q', 'k-q,q'],
[0, 1], [True, True],
beta=self.beta)
# factors of 2?
# needs to agree with normal state when things are diagonal
return -(1 / 2) * self.g0**2 / self.nk**2 * out
def compute_S_real_axis(GR, DR, Gsum):
# compute selfenergy from Marsiglio formula
B = -1.0 / pi * DR.imag
GRloc = sum(GR, axis=0)
return -g**2*dw/Nk*(conv(B, Gsum, ['z,w-z'], [0], [False])[:len(w)] \
-conv(B*(1+nB), GRloc, ['z,w-z'], [0], [False])[:len(w)] \
+conv(B, GRloc*nF, ['z,w-z'], [0], [False])[:len(w)])
def compute_gamma(self, F0gamma, D, jumpF0gamma, jumpD):
if hasattr(self, 'gq2'):
return 1 - self.g0**2 / self.nk**2 * conv(
F0gamma,
self.gq2[:, :, None] * D, ['k-q,q', 'k-q,q', 'm,n-m'],
[0, 1, 2], [True, True, False],
self.beta,
kinds=('fermion', 'boson', 'fermion'),
op='...,...',
jumps=(jumpF0gamma, jumpD))
elif hasattr(self, 'gk2'):
return 1 - self.g0**2 * self.gk2[:, :, None] / self.nk**2 * conv(
F0gamma,
D, ['k-q,q', 'k-q,q', 'm,n-m'], [0, 1, 2], [True, True, False],
self.beta,
kinds=('fermion', 'boson', 'fermion'),
op='...,...',
jumps=(jumpF0gamma, jumpD))
else:
return 1 - self.g0**2 / self.nk**2 * conv(
F0gamma,
D, ['k-q,q', 'k-q,q', 'm,n-m'], [0, 1, 2], [True, True, False],
self.beta,
kinds=('fermion', 'boson', 'fermion'),
op='...,...',
jumps=(jumpF0gamma, jumpD))
def compute_S(self, G, D):
if hasattr(self, 'gq2'):
return -self.g0**2 / self.nk**2 * conv(G, self.gq2[:, :, None] * D,
['k-q,q', 'k-q,q'], [0, 1],
[True, True], self.beta)
elif hasattr(self, 'gk2'):
return -self.g0**2 / self.nk**2 * self.gk2[:, :, None] * conv(
G, D, ['k-q,q', 'k-q,q'], [0, 1], [True, True], self.beta)
else:
return -self.g0**2 / self.nk**2 * conv(
G, D, ['k-q,q', 'k-q,q'], [0, 1], [True, True], self.beta)
def compute_GG(self, G):
if hasattr(self, 'gq2'):
return 2.0 / self.nk**2 * self.gq2[:, :, None] * conv(
G, -G[:, :, ::-1], ['k,k+q', 'k,k+q'], [0, 1], [True, True],
self.beta)
elif hasattr(self, 'gk2'):
return 2.0 / self.nk**2 * conv(self.gk2[:, :, None] * G,
-G[:, :, ::-1], ['k,k+q', 'k,k+q'],
[0, 1], [True, True], self.beta)
else:
return 2.0 / self.nk**2 * conv(
G, -G[:, :, ::-1], ['k,k+q', 'k,k+q'], [0, 1], [True, True],
self.beta)
def compute_GG(self, G):
#tau3G = einsum('ab,kwbc->kwac', Migdal.tau3, G)
#return 1.0/self.nk * trace(conv(G, -G[:,::-1], ['k,k+q'], [0], [True], beta=self.beta, op='...ab,...bc->...ac'), axis1=-2, axis2=-1)
return 2.0 / self.nk * conv(G,
-G[:, ::-1], ['k,k+q'], [0], [True],
beta=self.beta,
op='...ab,...bc->...ac')
def compute_PI(G):
tau3G = einsum('ab,kwbc->kwac', tau3, G)
return 2.0 * g**2 / (beta * Nk) * 0.5 * einsum(
'kwaa->kw',
conv(tau3G,
tau3G, ['k,k+q', 'm,m+n'], [0, 1], [True, False],
op='kwab,kwbc->kwac')[:Nk, :Nw + 1, :, :])
def main(src, dst):
src_pic_paths = [
os.path.join(src, name) for name in os.listdir(src)
if os.path.splitext(name)[-1] in [".jpg", ".JPG", ".png", ".PNG"]
]
filters = [
'Naive', # Naive Filter 原图滤波（相当于无变化）
'Sharpness_Center', # Sharpness_Center Filter 中心锐化 滤波
'Sharpness_Edge', # Sharpness_Edge Filter 边缘锐化 滤波
'Edge_Detection_360_degree', # Edge_Detection_360° Filter 360°边缘检测 滤波
'Edge_Detection_45_degree', # Edge_Detection_45° Filter 45°边缘检测 滤波
'Embossing_45_degree', # Embossing_45° Filter 45°浮雕 滤波
'Embossing_Asymmetric', # Embossing_Asymmetric Filter 非对称浮雕 滤波
'Averaging_Blur', # Averaging_Blur Filter 均值模糊 滤波
'Completed_Blur', # Completed_Blur Filter 完全模糊 滤波
'Motion_Blur', # Motion_Blur Filter 运动模糊 滤波
'Gaussian_Blur', # Gaussian_Blur Filter 高斯模糊 滤波
'DIY' # DIY Filter 自定义 滤波
]
# ===================================================================
## Choose the filter from list: "filter_names" 选择你需要的滤波器
filter_name = 'Sharpness_Center'
# filter_name = 'DIY'
# ===================================================================
for src_pic_path in src_pic_paths:
img = cv2.imread(src_pic_path)
h, w, c = img.shape
assert c == 3, "Error! Please use the picture of 3 color channels."
filter_0, filter_1, filter_2 = filter.Filter(filter_name)
img2 = np.zeros((h, w, c), dtype=np.float)
for i in range(1, h - 1, 1):
for j in range(1, w - 1, 1):
img2[i][j][0] = convolution.conv(img, filter_0, i, j)
img2[i][j][1] = convolution.conv(img, filter_1, i, j)
img2[i][j][2] = convolution.conv(img, filter_2, i, j)
dst_pic_name = filter_name + '.jpg'
dst_pic_path = os.path.join(dst, dst_pic_name)
cv2.imwrite(dst_pic_path, img2)
img3 = cv2.imread(dst_pic_path)
cv2.imshow(dst_pic_name, img3)
cv2.waitKey(0)
cv2.destroyAllWindows()
def compute_PI(G):
tau3G = einsum('ab,...bc->...ac', tau3, G)
return 2.0 * g**2 / (beta * Nk**2) * 0.5 * einsum(
'...aa->...',
conv(tau3G,
tau3G, ['k,k+q', 'k,k+q', 'm,m+n'], [0, 1, 2],
[True, True, False],
op='...ab,...bc->...ac')[:, :, :Nw + 1, :, :])
def compute_x0(self, F0x, D, jumpF0, jumpD):
return -self.g0**2 / self.nk**2 * conv(
F0x,
D, ['k-q,q', 'k-q,q', 'm,n-m'], [0, 1, 2], [True, True, False],
self.beta,
kinds=('fermion', 'boson', 'fermion'),
op='...,...',
jumps=(jumpF0, jumpD))
def test_conv1(N):
x = random.randn(N)
y = random.randn(N)
z = zeros(N)
for ik in range(N):
for iq in range(N):
z[ik] += x[iq] * y[((ik-iq)+N//2)%N]
w = conv(x, y, ['q,k-q'], [0], [True], None, kinds=(None,None,None))
print(amax(abs(w-z)))
def compute_S(self, G, D):
if hasattr(self, 'gk2'):
tau3Gtau3 = einsum('ab,kqwbc,cd->kqwad', Migdal.tau3, G,
Migdal.tau3)
return -self.g0**2 / self.nk**2 * self.gk2[:, :, None, None,
None] * conv(
tau3Gtau3,
D[:, :, :, None,
None],
['k-q,q', 'k-q,q'],
[0, 1],
[True, True],
beta=self.beta)
else:
tau3Gtau3 = einsum('ab,kqwbc,cd->kqwad', Migdal.tau3, G,
Migdal.tau3)
return -self.g0**2 / self.nk**2 * conv(tau3Gtau3,
D[:, :, :, None,
None], ['k-q,q', 'k-q,q'],
[0, 1], [True, True],
beta=self.beta)
def compute_GG(self, G):
if hasattr(self, 'gk2'):
tau3G = einsum('ab,kqwbc->kqwac', Migdal.tau3, G)
return 1.0 / self.nk**2 * trace(conv(
self.gk2[:, :, None, None, None] * tau3G,
-tau3G[:, :, ::-1], ['k,k+q', 'k,k+q'], [0, 1], [True, True],
beta=self.beta,
op='...ab,...bc->...ac'),
axis1=-2,
axis2=-1)
else:
tau3G = einsum('ab,kqwbc->kqwac', Migdal.tau3, G)
# ARE WE SURE ABOUT THE THE ::-1 TERM? DOES ANYTHING NEED TO HAPPEN WITH THE NAMBU INDICES?
return 1.0 / self.nk**2 * trace(conv(
tau3G,
-tau3G[:, :, ::-1], ['k,k+q', 'k,k+q'], [0, 1], [True, True],
beta=self.beta,
op='...ab,...bc->...ac'),
axis1=-2,
axis2=-1)
def main():
original_images = ['Elegent_Girl.jpg']
filter_names = [
'Naive', 'Sharpness_Center', 'Sharpness_Edge',
'Edge_Detection_360_degree', 'Edge_Detection_45_degree',
'Embossing_45_degree', 'Embossing_Asymmetric', 'Averaging_Blur',
'Completed_Blur', 'Motion_Blur', 'Gaussian_Blur'
]
# Choose the filter from list:'filter_names'
filter_name = 'Naive'
for original_image in original_images:
original_image_path = os.path.join(os.getcwd()[:-3], 'Image_Origin/',
original_image)
img = cv2.imread(original_image_path, 3)
filter_0, filter_1, filter_2 = filter.Filter(filter_name)
img2 = np.zeros((424, 600, 3), dtype=np.float)
for i in range(1, 423, 1):
for j in range(1, 599, 1):
img2[i][j][0] = convolution.conv(img, filter_0, i, j)
img2[i][j][1] = convolution.conv(img, filter_1, i, j)
img2[i][j][2] = convolution.conv(img, filter_2, i, j)
generated_image = filter_name + '.jpg'
generated_image_path = os.path.join(os.getcwd()[:-3],
'Image_Generated/',
generated_image)
cv2.imwrite(generated_image_path, img2)
img_show = cv2.imread(generated_image_path)
cv2.imshow(generated_image, img_show)
cv2.waitKey(0)
cv2.destroyAllWindows()
def poly(roots):
#Esta función retorna un vector con los coeficientes de un polinomio que corresponde
#a la lista de polos o raices dadas en 'Polos'
#Ejemplo de uso de la función poly en Python
#print poly([-0.5+3*1j, -0.5-3*1j, 4]) => s^3-3s^2+5.25s-37
orden = len(roots)
poli = [0 for x in range(0,orden)]
poliaux = -roots[0]
for k in range(0,orden-1):
if k == 0:
poli[k+1] = conv.conv([1,poliaux],[1,-roots[k+1]])
else:
poli[k+1] = conv.conv(poliaux,[1,-roots[k+1]])
poliaux = poli[k+1]
for k in range(0,len(poliaux)):
if poliaux[k].imag == 0:
poliaux[k] = poliaux[k].real
return poliaux
def convolution():
if 'imgFile' not in request.files:
return json.dumps({'status': 'Error1'})
file = request.files['imgFile']
if file.filename == '':
return json.dumps({'status': 'Error2'})
image = request.files['imgFile']
img_path = 'static/images/image.png'
method = request.form.get('method')
image.save(app.root_path + '/' + img_path)
new_image = conv(img_path, app.root_path, method, 0)
norm_img_path = 'static/images/normalized_image.png'
new_image.save(app.root_path + '/' + norm_img_path)
return json.dumps({'url_after': norm_img_path + '?' + str(time.time())})
def compute_S(G, D):
return -g**2 / (beta * Nk) * conv(
einsum('ab,wbc,cd->wad', tau3, sum(G, axis=0), tau3),
D[:, None, None] * ones([len(vn), 2, 2]), ['m,n-m'], [0], [False])[:Nw]
def compute_S(G, D):
return -g**2 / (beta * Nk) * conv(G, D, ['k-q,q', 'm,n-m'], [0, 1],
[True, False])[:, :Nw]
def compute_PI_real_axis(GR, Gsum):
GA = conj(GR)
A = -1.0 / pi * GR.imag
return 2.0*g**2*dw/Nk*(conv(A, Gsum, ['k+q,k','z,w-z'], [0,1], [True,False])[:,:len(w)] \
-conv(A, GA*nF[None,:], ['k+q,k','w+z,z'], [0,1], [True,False])[:,:len(w)] \
+conv(A*nF[None,:], GA, ['k+q,k','w+z,z'], [0,1], [True,False])[:,:len(w)])
def compute_PI(G):
return 2.0 * g**2 / (beta * Nk) * conv(G, G, ['k,k+q', 'm,m+n'], [0, 1],
[True, False])[:, :Nw + 1]
def compute_S(self, G, D):
tau3Gtau3 = einsum('ab,kwbc,cd->kwad', Migdal.tau3, G, Migdal.tau3)
return -self.g0**2 / self.nk * conv(tau3Gtau3,
D[:, :, None, None], ['k-q,q'],
[0], [True],
beta=self.beta)
def compute_S_real_axis(GR, DR, Gsum):
# compute selfenergy from Marsiglio formula
B = -1.0 / pi * DR.imag
return -g**2*dw/Nk*(conv(B, Gsum, ['k-q,q','z,w-z'], [0,1], [True,False])[:,:len(w)] \
-conv(B*(1+nB)[None,:], GR, ['k-q,q','z,w-z'], [0,1], [True,False])[:,:len(w)] \
+conv(B, GR*nF[None,:], ['k-q,q','z,w-z'], [0,1], [True,False])[:,:len(w)])
def compute_S(G, D):
return -g**2 / (beta * Nk) * conv(sum(G, axis=0), D, ['m,n-m'], [0],
[False])[:Nw]
def compute_GG(self, G):
return 2.0 / self.nk * self.gq2[:, None] * conv(
G, -G[:, ::-1], ['k,k+q'], [0], [True], self.beta)
def compute_S(self, G, D):
return -self.g0**2 / self.nk * conv(G, self.gq2[:, None] * D,
['k-q,q'], [0], [True], self.beta)
def compute_GG(self, G):
return 2.0 / self.nk**2 * conv(G, -G[:, :, ::-1], ['k,k+q', 'k,k+q'],
[0, 1], [True, True], self.beta)
def compute_S(self, G, D):
return -self.g0**2 / self.nk**2 * conv(G, D, ['k-q,q', 'k-q,q'],
[0, 1], [True, True], self.beta)
def compute_S(self, G, D):
#tau3Gtau3 = einsum('ab,kwbc,cd->kwad', Migdal.tau3, G, Migdal.tau3)
return -self.g0**2 / self.nk * conv(G,
D, ['k-q,q'], [0], [True],
beta=self.beta,
op='...ab,...bc->...ac')
