'''Definire una classe Pixel e una classe PImage secondo le seguenti specifiche.

La classe Pixel rappresenta un pixel cioe' un colore RGB con un livello di opacita'. Il livello di opacita' e' un intero da 0 a 255 con 0 rappresentante la completa trasparenza e 255 la totale opacita'. La classe Pixel deve implementarei seguenti metodi:
- Costruttore con argomenti r,g,b,op che inizializza il pixel con colore RGB (r,g,b) e livello di opacita' op.
- set_RGB(r, g, b) imposta il colore RGB del pixel con i valori r,g,b e ritorna l'oggetto stesso.
- set_opacity(op) imposta il livello di opacita' del pixel a op.
- to_tuple() ritorna una tupla (r,g,b,op) dove (r,g,b) e' il colore e op e' il livello di opacita' del pixel.
- enhance() intensifica il colore del pixel modificando ogni componente RGB c nel seguente modo:
se 50 <= c <= 200 allora il nuovo valore e' (255*(c - 50))/150
altrimenti se c < 50 il nuovo valore e' 0 e se c > 200 e' 255.
- blend(p) modifica il pixel miscelandolo con il pixel p (oggetto di tipo Pixel) nel seguente modo. Se (r,g,b,op) e' il valore dell'oggetto e (rp,gp,bp,opp) e' il valore del pixel p, allora ogni componente colore c e' modificata cosi' c = (opp*cp + (255 - opp)*c)/255 (divisione intera) e l'opacita' cosi' op = (255*(opp+ op) - opp*op)/255 (divisione intera).

La classe PImage rappresenta un'immagine che si consiglia di implementare come matrice (lista di liste) di oggetti Pixel. Deve implementare i seguenti metodi:
- Costruttore con argomenti (opzionali) fname=None, size=None. Se fname non e' None, inizializza l'immagine dell'oggetto con l'immagine PNG letta dal file fname con tutti i pixel totalmente opachi (l'argomento size e' ignorato). Se fname e' None e size non e' None, size deve essere una coppia (w,h) e inizializza l'immagine dell'oggetto con un'immagine di larghezza w, altezza h e con tutti i pixel di colore nero (RGB (0,0,0)) totalmente opachi. Si assume che almeno uno dei due argomenti non e' None.
- size() ritorna una coppia (w,h) dove w e h sono la larghezza e l'altezza dell'immagine.
- get_pixel(x, y) ritorna l'oggetto Pixel in posizione (x,y) dell'immagine (cioe' quello nella riga y e colonna x). L'oggetto Pixel ritornato e' proprio quello usato dall'immagine, per cui modificandolo si modifica l'immagine. Se (x,y) non e' all'interno dell'immagine, ritorna None.
- opacity(x, y, t=150) modifica l'opacita' di ogni pixel p dell'immagine secondo la formula:
nuova opacita' di p = (d*op)/(d + t) (divisione intera) dove d = abs(xp - x) + abs(yp - y) + abs(rp - r) + abs(gp - g) + abs(bp - b) e (xp,yp), (rp,gp,bp), op sono, rispettivamente la posizione, il colore e l'opacita' di p e (r,g,b) e' il colore del pixel in posizione (x,y).
- superimpose(x, y, pimg) sovrappone l'immagine pimg (di tipo PImage) sull'immagine dell'oggetto con lo spigolo in alto a sinistra in (x, y). Ogni pixel dell'immagine dell'oggetto p che si sovrappone a un pixel pp dell'immagine pimg e' modificato tramite il metodo blend (p.blend(pp)).
- subimg(x, y, w, h) ritorna un nuovo oggetto immagine (di tipo PImage) che contiene la porzione rettangolare dell'immagine dell'oggetto che ha lo spigolo in alto a sinistra in (x,y), larghezza w e altezza h. Si assume che il rettangolo sia interamente contenuto nell'immagine dell'oggetto.
- enhance() applica il metodo enhance a tutti i pixel dell'immagine.
- save(fname) salva l'immagine (in formato PNG) nel file fname, senza tener conto dell'opacita'

Se necessario, si possono aggiungere altri metodi ad entrambe le classi.

e qual è il problema?

Ciao pygerry95 non credo di aver capito bene cosa stai chiedendo. Dal titolo intuisco che chiedi aiuto per creare il tuo programma, ma non è così il miglior modo. Visto che dai tutta la "lista della spesa" e sembri avere le idee chiare, non vedo perché tu non possa sporcarti le manine sante con un po' di codice.

Poi se qualcosa non va possiamo vederlo insieme, ma da qui a farci scrivere il programma per te ce ne passa della proverbiale acqua sotto i ponti.

Torna presto a trovarci e porta in dono un po' di codice.

Ciao.
Daniele aka Palmux

eh si avete ragione sono nuovo ..
questo è quello che ho scritto fino ad ora:

import image as im

'''Implementare qui la classe Pixel'''

class Pixel(object):

    def __init__(self,r,g,b,op):
        self.r = r
        self.g = g
        self.b = b
        self.op = op

    def set_RGB(self,r,g,b):
        self.r = r
        self.g = g
        self.b = b
        return self

    def set_opacity(self,op):
        self.op = op

    def to_tuple(self):
        return (self.r, self.g, self.b, self.op)

    def enhance(self):
        if self.r < 50:
            self.r = 0
        else:
            if self.r > 200:
                self.r = 255
            else:
                self.r = (255*(self.r - 50))/150
        if self.g < 50:
            self.g = 0
        else:
            if self.g > 200:
                self.g = 255
            else:
                self.g = (255*(self.g - 50))/150
        if self.b < 50:
            self.b = 0
        else:
            if self.b > 200:
                self.b = 255
            else:
                self.b = (255*(self.b - 50))/150

    def blend(self,p):
        rp = p.r
        gp = p.g
        bp = p.b
        opp = p.op 
        self.r= (opp*rp + (255 - opp)*self.r)/255
        self.g = (opp*gp + (255 - opp)*self.g)/255
        self.b = (opp*bp + (255 - opp)*self.b)/255
        self.op = (255*(opp+ self.op) - opp*self.op)/255


#p = Pixel(10,10,10,10)
#print (p.r, p.g, p.b, p.op)
#p.set_RGB(12,12,12)
#print (p.r, p.g, p.b, p.op)
#p.set_opacity(21)
#print (p.r, p.g, p.b, p.op)
#p.enhance()
#print (p.r, p.g, p.b, p.op)
#p2 = Pixel(30,30,30,30)
#p.blend(p2)
#print (p.r, p.g, p.b, p.op)

'''Implementare qui la classe PImage'''

class PImage(object):
    def __init__(self,fname=None, size=None):
        self.fname = fname
        self.size = size 
        self.matrix = [ ]    
        if fname == None:
            if size == None:
                print "Almeno uno dei due parametri deve essere diverso da None"
        else:            
            self.img = im.load(self.fname)
            h = len(self.img)
            w = len(self.img[ 0 ])
            for j in range(h):
                for i in range(w):
                    self.img[ j ] = self.img[ j ] + (255,)
            #print self.img
            #print "h:%d" % h 
            #print "w:%d" % w            
            #print self.img[ 0 ]
            #print self.img[ 0 ][ 0 ]
            #print self.img[ 0 ][ 0 ][ 1 ]
 #           self.img = self.matrix.append(Pixel(0, 0, 0, 255))
#        if fname == None:
#            if not size == None:
#                    (w, h) = self.size
#                    self.img = (w, h)
#                    (w, h) = len(self.img[ 0 ]), len(self.img)
#        return self._pixels.append(Pixel(0, 0, 0, 255))



#Costruttore con argomenti (opzionali) fname=None, size=None. Se fname non e'
#  None, inizializza l'immagine dell'oggetto con l'immagine PNG letta dal file
#  fname con tutti i pixel totalmente opachi (l'argomento size e' ignorato). Se
#  fname e' None e size non e' None, size deve essere una coppia (w,h) e
#  inizializza l'immagine dell'oggetto con un'immagine di larghezza w, altezza h
#  e con tutti i pixel di colore nero (RGB (0,0,0)) totalmente opachi. Si assume
#  che almeno uno dei due argomenti non e' None.

    def size(self,w,h):
        w = len(self.img[ 0 ])
        h = len(self.img)
        return (w,h)

    def get_pixel(self, x, y):
        if 0 <= x < self.size[ 0 ] and 0 <= y < self.height[ 1 ]:
            return self.img[ y ][ x ]
        else: 
            return None

adesso dovrei implementare l'oggetto opacity come descritto li sopra ma non so come fare... aiuto



--- Ultima modifica di C8E in data 2014-11-25 09:20:54 ---

--- Ultima modifica di C8E in data 2014-11-25 10:21:56 ---