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')