Salut,
j'ai pas mal de problemes de vignettage avec mon APN lorsque je fais des
montages de panoramiques
j'essaye de supprimer le vignettage des photos en la "divisant" par un
filtre représentant le vignettage (premier programme joint, mais gimp
fait cela tres bien aussi). ca marche bien.
j'essaye de déterminer le vignettage en considerant qu'un ciel clair
doit être uniforme (moyenne sur 10 lignes), a mon avis cette solution
est pas mal pour calibrer son objectif. (second programme)
si je travaille en RGB, j'ai un filtre qui est loin d'être gris, il est
plutot dégradé en bleu et tent a donner une surcorrection et surtout une
dérive des couleurs.
si je travaille en "gris" (1/4 rouge, 1/4 bleu 1/2 vert) j'ai une
surcorrection.
j'hesite a travailler en TSV (enfin plutot sur S ou V)
travailler sur la valeur risque d'être pire que tout, je sais pas ce que
cela peut donner saturation ... mais peut être avez vous une idée sur le
sujet ? car moi je commence vraiment a demander si c'est pas plus simple
de changer d'APN que de corriger le vignettage.
A++
--
Jérôme Kieffer
#######################################################################
#!/usr/bin/python
import os,sys,Image,ImageFilter,math,ImageChops
#the aim of this programm is to remove the vignetting of a photo by
#dividing by a filter
if len(sys.argv)==3:
filt=sys.argv[2]
filename=sys.argv[1]
elif len(sys.argv)==2:
filename=sys.argv[1]
filt="filter.png"
else:
raise "Please enter the name of the photo (and the filter)"
try:
I=Image.open(filename)
F=Image.open(filt)
except:
raise "either the file %s or the filter %s is not readable
!!!"%(filename,filt)
G=F.convert("RGB")
H=ImageChops.invert(I.convert("RGB"))
J=ImageChops.invert(ImageChops.multiply(H,G))
#J=ImageChops.invert(ImageChops.multiply(F,ImageChops.invert(I)))
J.save(os.path.splitext(filename)[0]+"-dv"+os.path.splitext(filename)[1
])
#######################################################################
#!/usr/bin/python
import os,sys,Image,ImageFilter,math,numarray
#the aim of this programm is to create a filter representing the
#vignetting a photo
def d(x,y):
return int(round(math.sqrt(x*x+y*y)))
def mean(arr):
s=0
for i in arr: s+=i
return 1.0*s/len(arr)
def Gaussian(radius):
"returns a table of 4*radius+1 representing the gaussian function"
t=[0.0]*(4*radius+1)
for i in range(4*radius+1):
t[i]=math.exp(-1.0*(i-2*radius)**2/radius**2)
s=0
for i in t:
s+=i
return numarray.array(t)/s
def GaussianBlur(data,radius):
"""Does the Gaussian Blur in one dimension of the data"""
G=Gaussian(radius)
tx = ([ data[0] ] * (2*radius)) + list(data) + ([ data[-2] ] *
(radius*2) )
rx = []
for i in range(radius*2,len(tx)-(radius*2)):
rx.append(numarray.matrixmultiply(G,numarray.array(tx[i-(2*radius):i+1+
2*radius])))
return rx
if len(sys.argv)==2:
filename=sys.argv[1]
else:
filename="11h30m14-u300D.jpg"
try:
I=Image.open(filename)
except:
raise "error in reading file : "+filename
J=I.convert("RGB")
(x,y)=I.size
xm=x/2
ym=y/2
F=Image.new("RGB", I.size, (255,255,255))
r={}
g={}
b={}
for i in range(d(xm,ym)+1):
r[i]=[]
g[i]=[]
b[i]=[]
for l in range(10):
for i in range(x):
u,v,w=J.getpixel((i,l))
r[d(i-xm,l-ym)].append(u)
g[d(i-xm,l-ym)].append(v)
b[d(i-xm,l-ym)].append(w)
R=[0]*(d(xm,ym)+1)
G=[0]*(d(xm,ym)+1)
B=[0]*(d(xm,ym)+1)
for i in range(len(R)):
if len(r[i])>0:R[i]=mean(r[i])
if len(g[i])>0:G[i]=mean(g[i])
if len(b[i])>0:B[i]=mean(b[i])
mr=max(R)
mg=max(G)
mb=max(B)
for i in range(d(xm,ym)+1):
if R[i]==0:R[i]=mr
if G[i]==0:G[i]=mg
if B[i]==0:B[i]=mb
r=GaussianBlur(numarray.array(R)*255.0/mr,50)
g=GaussianBlur(numarray.array(G)*255.0/mg,50)
b=GaussianBlur(numarray.array(B)*255.0/mb,50)
f=open("test.dat","w")
for i in range(len(R)):
f.write("%s %s %s %s %s %s %s\n"%(i,R[i],r[i],G[i],g[i],B[i],b[i]))
f.close()
for i in range(x):
for j in range(y):
dist=d(i-xm,j-ym)
if r[dist]<255 or g[dist]<255 or b[dist]<255:
F.putpixel((i,j),(int(r[dist]),int(g[dist]),int(b[dist])))
F.save("filter.png")
