python中的色差估计

Hi此代码通过给出红色和绿色通道之间以及蓝色和绿色通道之间的畸变中心（x，y）和畸变幅度（alpha）来估计图像中的色差。WarpRegion函数中有一个错误

File "CAfeb.py", line 217, in warpRegion
    reg_w = sp.interpolate.interp2d(yrampf,xrampf,Cwarp, yramp1f, xramp1f,'cubic');
  File "/usr/lib/python2.7/dist-packages/scipy/interpolate/interpolate.py", line 109, in __init__
    'quintic' : 5}[kind]
TypeError: unhashable type: 'numpy.ndarray'

下面是完整的代码-任何帮助都将不胜感激，谢谢。阿雷伊

import math
from PIL import Image 
import numpy as np
from decimal import Decimal
import scipy as sp
from scipy import interpolate
from scitools.std import ndgrid
from scipy import ogrid, sin, mgrid, ndimage, array


def ldimage():
    #load image
    global im
    im = Image.open("/home/areej/Desktop/mandril_color.tif") 

def analyzeCA(mode, im):
    n_regions = 10;
    reg_size = [300, 300];
    overlap = 0.5;


    levels = 9;
    steps = 2;
    edge_width = 10;
    hist_sz = 128;

   # alpha_1 and alpha_2 are assumed to be between these values
    w_data = [0.9985, 1.0015];

    reg_list=[]

   #creating an array of pixels so that we can access them
    pix=im.load()

#
#Analyze full image

    if mode=='full':
        print "Doing a full analysis"
        # mx_shift is the third argument in 'full' mode
        mx_shift = n_regions;
            # [ydim,xdim,zdim]= size(im);
        ydim=im.size[0]
        xdim=im.size[1]
        zdim=3

        print "Image dimensions: [ydim, xdim, zdim]= "+str([ydim,xdim,zdim])


        global alpha_mx, alpha_mn
        alpha_mx = 1 + 4*mx_shift / math.sqrt( xdim*xdim + ydim*ydim );
        alpha_mn = 1.0/alpha_mx;

        print "alpha_mx= "+str(alpha_mx)
        print "alpha_mn= "+str(alpha_mn)
        #recompute alpha_1 and alpha_2 to be between
        #these new values
        w_data = [alpha_mn, alpha_mx];
        ew = edge_width;

        #take the image minus a ew-wide edge
        roi = [ew+1, xdim-ew, ew+1, ydim-ew];

        print "edge_width= "+str(ew)
        print "roi= "+str(roi)

        #Analyze blue to green chromatic aberration
        bg_params = parameterSearch( im, [3, 2], roi, ew, hist_sz, w_data);

        # Analyze red to green chromatic aberration
        rg_params = parameterSearch( im, [1, 2], roi, ew, hist_sz, w_data );
    elif mode=='reg':
      print "we should do a regional analysis here"

    else:
     print "unsupported call"
#def estimateCARegions( im, [3, 2], reg_list, settings ):
def parameterSearch( im, colour_space, roi, ew, hist_sz, w_data):

    #levels is number of iterations 
    levels = 8;
    steps = 2;

    #[ydim,xdim,zdim] = size(im);
    ydim=im.size[0]
    xdim=im.size[1]
    zdim= 3


    x_data = [1, xdim];
    y_data = [1, ydim];

    xlim = x_data;
    ylim = y_data;
    zlim = w_data;

#work out which of height and width is the bigger
    dim = max(xdim,ydim)

    print "The highest dimension is : "+str(dim)

#check that roi falls within expected boundries
    if ((roi[0] <= ew) or (roi[1] > xdim-ew) or (roi[2] <= ew) or (roi[3] > ydim-ew)):
        print "ROI is too close to image edges"
        return -1 # TODO: terminate here with an error
        #Get image regions

    source = im.split()
    Cfixed = source[2]
    Cwarp  = source[1]
    #[ydim,xdim,zdim] = size(im);
    ydimCwarp=Cwarp.size[0]
    xdimCwarp=Cwarp.size[1]
    print 'xdimCwarp'+str(xdimCwarp)

    roi_pad = [roi[0]-ew, roi[1]+ew, roi[2]-ew, roi[3]+ew];
    for levels in range(1,8):
    #Guess at a center and then compute best warp
    #user defined function linear_space used to generate linearly spaced vectors
        x_coords = np.linspace(0,511,steps+2)
        y_coords = np.linspace(0,511,steps+2)
        z_coords = np.linspace(alpha_mn,alpha_mx,steps+2)
        step_x=(xlim[1]-xlim[0])/(steps+1)
        start_x=xlim[0]+step_x
        end_x=xlim[1]-step_x+0.5
        step_y=(ylim[1]-ylim[0])/(steps+1)
        start_y=ylim[0]+step_y
        end_y=ylim[1]-step_y+0.5
        step_z=(zlim[1]-zlim[0])/(steps+1)
        start_z=zlim[0]+step_z
        fudge_z=step_z/2.0
        end_z=zlim[1]-step_z+fudge_z
        #Do not include end points in search;
        centers_x, centers_y, warps= np.mgrid[start_x:end_x:step_x,start_y:end_y:step_y,start_z:end_z:step_z]
        centers_x=centers_x.flatten()
        centers_y=centers_y.flatten()
        warps=warps.flatten()
        mi = np.zeros(centers_x.size)

        for k in range(0,centers_x.size):
           cx = centers_x[k]
           cy = centers_y[k]
           wz = warps[k]       
           #Warp the region 
           temp_im = warpRegion(Cwarp, roi_pad, [cx, cy, wz])
                #correlation
           mi[k] = np.corrcoef(Cfixed, temp_im)
               #Now pick the best quadrant
        v, max_ix = math.max(mi)
        ix, jx, kx = arrayInd(mi.size, max_ix);
        ##The coordinates of err are off by 1 from x_coords and y_coords because
        ##we did not include the end point
    xlim = x_coords([jx, jx+2]);
    ylim = y_coords([ix, ix+2]);
    zlim = z_coords([kx, kx+2]);

    cx = math.mean(xlim);
    cy = math.mean(ylim);
    wz = math.mean(zlim);

    print "x= "+str(cx)
    print "y= "+str(cy)
    print "z= "+str(wz)
def warpRegion(Cwarp, roi_pad, (cx, cy, wz)):
#Unpack region indices
    sx, ex, sy, ey = roi_pad

    xramp, yramp = np.mgrid[sx:ex+1, sy:ey+1]

    xrampc = xramp - cx;
    yrampc = yramp - cy;
    xramp1 = 1/wz*xrampc;
    yramp1 = 1/wz*yrampc;
    xrampf = xrampc.flatten()
    yrampf = yrampc.flatten()
    xramp1f = xramp1.flatten()
    yramp1f = yramp1.flatten()
    reg_w = sp.interpolate.interp2d(yrampf,xrampf,Cwarp, yramp1f, xramp1f,'cubic');

ldimage()
analyzeCA('full', im)

导入数学
从PIL导入图像
将numpy作为np导入
从十进制输入十进制
将scipy作为sp导入
从scipy导入插值
从scitools.std导入ndgrid
从scipy导入ogrid、sin、mgrid、ndimage、数组
def ldimage（）：
#加载图像
全球即时通讯
im=Image.open（“/home/areej/Desktop/mandril_color.tif”）
def分析仪（模式，im）：
n_区=10；
注册大小=[300300]；
重叠=0.5；
级别=9；
步骤=2；
边缘宽度=10；
hist_sz=128；
#假设alpha_1和alpha_2介于这些值之间
w_数据=[0.9985,1.0015]；
注册列表=[]
#创建一个像素数组以便我们可以访问它们
pix=im.load（）
#
#分析完整图像
如果模式=='full'：
打印“进行全面分析”
#mx_shift是“full”模式下的第三个参数
mx_移位=n_区域；
#[ydim，xdim，zdim]=尺寸（im）；
ydim=im.size[0]
xdim=im.size[1]
zdim=3
打印“图像尺寸：[ydim，xdim，zdim]=”+str（[ydim，xdim，zdim]）
全球alpha_mx，alpha_mn
alpha_mx=1+4*mx_shift/math.sqrt（xdim*xdim+ydim*ydim）；
alpha_mn=1.0/alpha_mx；
打印“alpha_mx=“+str（alpha_mx））
打印“alpha_mn=“+str（alpha_mn））
#重新计算alpha_1和alpha_2之间的值
#这些新价值观
w_数据=[alpha_mn，alpha_mx]；
ew=边缘宽度；
#将图像减去ew宽边
投资回报率=[ew+1，xdim-ew，ew+1，ydim-ew]；
打印“边缘宽度=”+str（ew）
打印“roi=”+str（roi）
#分析蓝绿色差
bg_params=参数搜索（im[3,2]，roi，ew，hist_sz，w_数据）；
#红绿色差分析
rg_params=参数搜索（im[1,2]，roi，ew，hist_sz，w_数据）；
elif模式=='reg'：
打印“我们应该在这里进行区域分析”
其他：
打印“不支持的呼叫”
#def估计区域（im、[3,2]、注册表、设置）：
def参数搜索（im、颜色空间、roi、ew、hist_sz、w_数据）：
#级别是迭代次数
级别=8；
步骤=2；
#[ydim，xdim，zdim]=尺寸（im）；
ydim=im.size[0]
xdim=im.size[1]
zdim=3
x_数据=[1，xdim]；
y_数据=[1，ydim]；
xlim=x_数据；
ylim=y_数据；
zlim=w_数据；
#计算出哪个高度和宽度更大
尺寸=最大值（xdim，ydim）
打印“最高尺寸为：”+str（尺寸）
#检查投资回报率是否在预期范围内
如果（（roi[0]xdim-ew）或（roi[2]ydim-ew））：
打印“ROI太接近图像边缘”
return-1#TODO:在此处终止并出现错误
#获取图像区域
source=im.split（）
Cfixed=源[2]
Cwarp=源[1]
#[ydim，xdim，zdim]=尺寸（im）；
ydimCwarp=Cwarp.size[0]
xdimCwarp=Cwarp.size[1]
打印'xdimCwarp'+str（xdimCwarp）
roi_pad=[roi[0]-ew，roi[1]+ew，roi[2]-ew，roi[3]+ew]；
对于范围（1,8）内的级别：
#猜测一个中心，然后计算最佳扭曲
#用于生成线性间隔向量的用户定义函数线性_空间
x_coords=np.linspace（0511，步骤+2）
y_coords=np.linspace（0511，步骤+2）
z_coords=np.linspace（alpha_mn，alpha_mx，steps+2）
步骤x=（xlim[1]-xlim[0]）/（步骤+1）
开始\u x=xlim[0]+步进\u x
结束\u x=xlim[1]-步骤\u x+0.5
步骤y=（ylim[1]-ylim[0]）/（步骤+1）
开始y=ylim[0]+步骤y
结束y=ylim[1]-步骤y+0.5
步骤z=（zlim[1]-zlim[0]）/（步骤+1）
开始=zlim[0]+步进
fudge_z=步骤_z/2.0
end_z=zlim[1]-步骤_z+fudge_z
#不要在搜索中包含终点；
中心线，中心线，扭曲=np.mgrid[开始线：结束线：步骤线，开始线：结束线：步骤线，开始线：结束线：步骤线，开始线：结束线：步骤线]
中心x=中心x.展平（）
中心线y=中心线y.展平（）
翘曲=翘曲。展平（）
mi=np.零（中心×尺寸）
对于范围内的k（0，中心×尺寸）：
cx=中心x[k]
cy=中心_y[k]
wz=翘曲[k]
#扭曲该区域
temp\u im=翘曲区域（Cwarp、roi\u焊盘[cx、cy、wz]）
#相关性
mi[k]=np.corrcoef（固定，临时）
#现在选择最佳象限
v、 max_ix=math.max（mi）
ix，jx，kx=阵列尺寸（最小尺寸，最大值ix）；
##err的坐标与x_坐标和y_坐标相差1，因为
##我们没有包括终点
xlim=x_坐标（[jx，jx+2]）；
ylim=y_坐标（[ix，ix+2]）；
zlim=z_坐标（[kx，kx+2]）；
cx=数学平均值（xlim）；
cy=数学平均值（ylim）；
wz=数学平均值（zlim）；
打印“x=”+str（cx）
打印“y=”+str（cy）
打印“z=”+str（wz）
def翘曲区域（Cwarp、roi_焊盘（cx、cy、wz））：
#解包区域索引
sx，ex，sy，ey=投资回报率
xramp，yramp=np.mgrid[sx:ex+1，sy:ey+1]
xrampc=xramp-cx；
yrampc=yramp-cy；
xramp1=1/wz*xrampc；
yramp1=1/wz*yrampc；
xrampf=xrampc.flatte（）
yrampf=yrampc.flatte（）
xramp1f=xramp1.flatte（）
yramp1f=yramp1.flatten（）
reg_w=sp.interpolate.interp2d（yrampf，xrampf，Cwarp，yramp1f，xramp1f，'cubic'）；
ldimage（）
analyzeCA（“完整”，即时消息）

正如DSM正确指出的，这不是interp2d的正确调用语法，可在上查看。如果您阅读调用语法，然后再次阅读错误消息（或模块本身，以您喜欢的为准），您会发现您正在尝试使用数组作为字典的索引，这将自然引发异常

我想你要做的是对数组xram给出的网格进行插值

interp_func = sp.interpolate.interp2d(yrampf, xrampf, Cwarp, kind='cubic')
reg_w = interp_func(yramp1f, xramp1f)