编辑：

Question

编辑：

简而言之：我有三张图片：参考图片和另外两张。参考图像用于将其他两个调整为适当的值。 -这部分应该没问题。然后我将其他两张图片（阵列）彼此相减，然后得到一些像素被隐藏的阵列-也完成了现在是棘手的部分：
enter image description here这是我想分别在每个像素中求解的方程，我的结果应该是新数组中的“ h”，并将其导出为excel 非常感谢您的帮助。

import scipy
import numpy as np
from PIL import Image
from scipy.optimize import fsolve                    


P0 = Image.open('3kanaly0.tif')                                                               
m = scipy.misc.imread("3kanaly0.tif")
P0 = m[:,:,0]
print(P0)

P0_T = np.array(P0)/4

#1image
m = scipy.misc.imread("3.tif")
P1 = m[:,:,0]
print(P1)

P1_T = np.array(P1)/4                               
print(P1_T.shape)
print("P1_T (z)",type(P1_T))
print(P1_T)


#adjust
Texp = input()
Texp = int(Texp)

print("Start beta")
def beta(Texp,Tcal = 20):
    return Texp/Tcal
b = beta(Texp)
print("beta :", b)
print(" beta")

print("Start alfa")
def alfa(A,B,C,D,b):
    return A*b**3+B*b**2+C*b+D
wynik_alfa = alfa(0.0097,-0.08,-0.038,1.016,b)
print("alfa i:",wynik_alfa)
print(" alfa")

#
Tcal = 20
a = -10.978
b = 22.76
c = -19.317
d = 8.4634
Temp_T =  Tcal*(a*(wynik_alfa*P1_T/P0_T)**3+b*(wynik_alfa*P1_T/P0_T)**2+c*wynik_alfa*P1_T/P0_T+d)




#2image
m = scipy.misc.imread("3kanaly2.tif")
P2 = m[:,:,0]

Temp_T2 =  Tcal*(a*(wynik_alfa*P2_T/P0_T)**3+b*(wynik_alfa*P2_T/P0_T)**2+c*wynik_alfa*P2_T/P0_T+d)




r = np.subtract(Temp_T,Temp_T2)



a = 20
k = 400
Tpow = 80.0
ro = 8920
cp = 384
t = 2

print(type(k))
print(type(Tpow))
print(type(ro))
print(type(cp))
print(type(t))
print(type(P1_T))
print(type(r))


for i in range(len(Temp_T)):
    for j in range(len(Temp_T2[0])):
        fsolve((r[i][j] + (Tpow -Temp_T[i][j])*(1-exp(h**2)*exp(a*t/k**2)*h*(a**0.5*t**0.5)/k)))

Answer 1

您的帖子有点模棱两可，但是无论如何我都会尽力帮助您。如上所述，我对您的问题的“可解决性”并不十分自信，因为我解释您作品的两种方式会导致两个不同的问题。据我了解，您正在尝试解决以下问题：

1）R = A(h)*P1

其中A是将图像P1连接到残差R=P1-P2的运算符，其取决于您具有给定值的多个变量（a，k，t），此外，这取决于您要查找的数量h。

如果是这样，则有两个选择。首先，如果h对于每个像素都是独立的-那么您追求的是N的h值-您的问题本质上是：

2）R[i][j] = A(h)[i][j] * P1[i][j]

N是像素数。请注意，2）不是矩阵方程，这里的乘法是元素方式的，而不是矩阵乘法。因此，我们在这里查看的是N个不相关的方程式。因此，您不应使用矩阵求解技术来找到解决方案。如果您不能重写2）使其显式（即h = ...），则将无法求解h。如果您无法使用数学编写方程式的解，则将无法编写解决该问题的程序。

第二个选项是您要查找h的单个值。在这种情况下，您要解决的问题是矩阵向量方程，该方程大致采用以下形式：

3）R[:] = A(h)P1[:]

其中R和P1已重组为长度为N的向量，A是某种形式（稀疏或稠密）的N×N矩阵。在这种情况下，因为矩阵A不是唯一的，所以我们无法解决问题。您有N个方程和N ^ 2个未知数。 h的多个值可能导致一个解决方案，或者该问题只能在最小二乘意义上解决。

如果您要解决的问题与我上面写的两个问题不同，请尝试以数学方式写下您要解决的问题，我认为这对寻找解决方案非常有帮助（如果它存在）。

Answer 2

啊，我明白了，您正在尝试使用fsolve解决h。 Fsolve将一个函数作为其初始参数，并将缺失值的初始猜测作为第二个参数。因此，您需要将方程式定义为一个函数：

def equation(h):
  return r[i][j] + (Tpow -P1_T[i][j])*(1-exp(h**2)*exp(a*t/k**2)*h*(a**0.5*t**0.5)/k)

然后将该函数传递给fsolve，并对h进行初始猜测（本例中为5）：

h_vals = np.zeros_like(P0_T)
for i in range(len(P1_T)):
    print(i)
    for j in range(len(P1_T[0])):
        a = fsolve(equation,5)
        h_vals[i][j] = a

根据您的图像，这可能需要很长时间才能计算出来。

通过隐式方程修改像素

编辑：

2 个答案: