Помощь при принятии матрицы к мощности постоянного

Question

ниже, я представил весь мой код для этой программы, которую я пытаюсь разработать. Что это такое, как при вводе, это файл N x 3; я приведу образец того, что im использует ниже (его просто образец 5x3). Каждый образец представляет собой координату пикселя в изображении, который был масштабирован до некоторой координаты XYZ с использованием многомерного масштабирования. Цель этой программы - перейти от координат XYZ к цвету LaB ... который может затем переводятся в sRGB. Код ниже (вторая часть) показывает преобразование из XYZ в LaB, а верхняя часть (с надписью Fast XYZ - RGB) - это ярлык, который я нашел, чтобы перейти от XYZ к RGB, вырезая шаг LaB. Проблема заключается в шаге Fast XYZ - RGB.

Что я пытаюсь сделать, это сделать sRGBmat = (1 + вал) * RGBLin^(1/2,4) - вал

Проблема, которую я держать работает в том, что из RGBLin иногда может быть отрицательным номер ... что означает, что я должен использовать Cmath или что-то еще. Я пробовал использовать Cmath, но он дал мне неправильные значения. В MatLab он дает мне правильное число (ну реальную + мнимую часть), которую я все еще могу использовать.

Файл xyztest.txt содержит матрицу 5х3 со следующими значениями:

.2345 .9817 .7612 
.5465 .7897 .3514 
.7796 .6765 .5645 
.1221 .6376 .8790 
.5432 .5853 .4652 

Выходной сигнал должен (с несколькими более вычислений) приводит к N х 3 матрицы, где каждая строка является представителем RGB в пикселе 1-n строки 1 (для первых n значений), затем строка 2 для следующих значений n + 1 -

Любая помощь будет принята с благодарностью!

import numpy as np 
d=open('xyztest.txt', 'r') 
import cmath 

a=[] 
count = 0 
b = [] 
AoverAn = [] 
XoX = [] 
YoY = [] 
ZoZ = [] 
aova=[] 
c = 0 
while 1: 
    line = d.readline() 
    a.append(line.split()) 
    count = count + 1 
    if not line: 
     break 
#print a #contains all of the line elements in a list 
t=[] 
XYZM = [] 

illuminant = [94.9423, 100.0000, 108.7201] 
##or is it [ .9424, 1.000, .8249] which is in matlab- 

#print count 
for i in range(count-1): 
    b = a[i:(i+1)] 
    #print "this is", b 
    c = b[0] 
    x = c[0] 
    y = c[1] 
    z = c[2] 
    XoverXn = round(float(x) /illuminant [0], 10) 
    YoverYn = round(float(y)/illuminant [1], 10) 
    ZoverZn = round(float(z)/illuminant [2], 10) 
    XoX.append(XoverXn) 
    YoY.append(YoverYn) 
    ZoZ.append(ZoverZn) 
    x.replace('\'', '') 
    mmaker = (float("".join(x)), float("".join(y)), float("".join(z))) 
    XYZM.append(mmaker) 

L = [] 
a = [] 
b = [] 
fXoX = [] 
fYoY = [] 
fZoZ = [] 
Lab = [] 

##print "YOUR XYZ MAT", XYZM 
##Get an XYZ matrix so i can use fast XYZ to RGB 

Fast XYZ> RGB

##A is the thing we want to multiply 
A= np.matrix('3.2410, -1.5374, -0.4986 ;-.9692, 1.8760, 0.0416 ; .0556, -.2040, 1.0570') 

##we get [R,G,B]' = A * [X,Y,Z]' 
##Must be in the range 0-1 
RGBLin=[] 
##XYZM = float(XYZM) 
print "XYZ" 
print XYZM 
xyzt = np.transpose(np.matrix(XYZM)) 
RGBLin = np.transpose(A * xyzt) 


val = 0.555 
temp = (RGBLin <= 0.00304) 
#print temp 


print "RGB" 
##print RGBLin 
## Do power multiplcation because numpy doesnt want to work for non square mat 
for i in range(len(RGBLin)): 
    for j in range(1): 
     rgbline = RGBLin[i].tolist() 
     for item in rgbline: 
      for i in range(3): 
       print item[i] 
       item[i] = 1.055 + item[i+1]**(1/2.4) 
       print item[i] 
      print item 
     #print rgbline 
     #te[i][j] = pow(RGBLin[i][j] , (1./2.4)) 
#print te 

-> Проблема заключается в этом шаге, я пытаюсь взять матрицу к мощности (1/2.4), но некоторые значения матрицы отрицательные. Как мне получить python, чтобы дать мне значение?!

#te = pow(RGBLin, (1./2.4)) 

XYZ -> LAB

for i in range(len(XoX)): 
    #print YoY[i] 

    xyz = [] 

    test = float(pow(YoY[i],(1./3))) 
    #print test 
    if (YoY[i] > 0.008856): 
     L.append((116 * (YoY[i] **(1./3))) - 16)    
     #L1 = (116 * (YoY[i] **(1./3))) - 16 
    else: 
     L.append(903.3* YoY[i]) 
     #L1 = 903.3* YoY[i] 
    ##  
    if (XoX[i] > 0.008856): 
     fXoX.append(pow(XoX[i], (1./3))) 
     #A1 = pow(XoX[i], (1./3)) 
    else: 
     fXoX.append((7.787 * XoX[i])+(16/116)) 
     #A1 = (7.787 * XoX[i])+(16/116) 
    ## 
    if (YoY[i] > 0.008856): 
     fYoY.append(pow(YoY[i], (1./3))) 
     #B1 = pow(YoY[i], (1./3)) 
    else: 
     fYoY.append((7.787 * YoY[i])+(16/116)) 
     #B1 = (7.787 * YoY[i])+(16/116) 
    ## 
    if (ZoZ[i] > 0.008856): 
     fZoZ.append(pow(ZoZ[i], (1./3))) 
     #Z1 = pow(ZoZ[i], (1./3)) 
    else: 
     fZoZ.append((7.787 * ZoZ[i])+(16/116)) 
     #Z1 = (7.787 * ZoZ[i])+(16/116) 
    ## 

    a.append(500*(fXoX[i]-fYoY[i])) 
    b.append(500*(fYoY[i]-fZoZ[i])) 
    xyz.append((L[i], a[i], b[i])) 
    ##print xyz 
######### NOW we must go from Lab to RGB, where XYZ is the LaB co-ordinates###### 

Answer 1

Скажите NumPy, что ваши номера являются сложными.

In [1]: import numpy as np 

In [2]: r = np.array([-5, 2, 8, -1]) 

In [3]: r ** (1/2.4) 
/usr/local/share/python3/ipython3:1: RuntimeWarning: invalid value encountered in power 
    #!/usr/local/Cellar/python3/3.2.2/bin/python3.2 
Out[3]: array([  nan, 1.33483985, 2.37841423,   nan]) 

In [4]: c = r.astype(complex) 

In [5]: c ** (1/2.4) 
Out[5]: 
array([ 0.50609696+1.88877958j, 1.33483985+0.j  , 
     2.37841423+0.j  , 0.25881905+0.96592583j]) 

Там какое-то обсуждение этого on scipy.org.