aggiungo: uso la versione 2.7.8 di python su ubuntu e devo usare per forza le librerie importate li
e cmq il programma quando vado a lanciarlo dall'IDLE non mi da alcun errore però non va come dico io aiuto..!

Praticante devo inserire 3 combobox e fino a qui ci sono. quello che non riesco a fare è far corrispondere le unità con le grandezze. Es:
se nella combobox_1 è selezionato lunghezza nelle combobox_2 e 3 dovranno contenere una lista delle relative unità dela lunghezza ([km, m, cm, mm])
questo è quello che ho scritto per adesso:

from PySide.QtGui import *
from PySide.QtCore import *
from testapp import startapp, runapp    # NON IMPORTARE NIENT'ALTRO DA testapp

# Crea l'oggetto QApplication, NON chiamare QApplication
startapp()    # NON MODIFICARE

# Inizio implementazione dell'applicazione
window = QWidget()
window.setWindowTitle('Program01')
window.resize(300,200)
layout_2 = QVBoxLayout()
items = ('lunghezza', 'area', 'volume')
units = (('chilometri','metri','centimetri','millimetri'),
('chilometri quadri','ettari','metri quadri','centimetri quadri','millimetri quadri'),
('metri cubi','centimetri cubi','millimetri cubi','litri','decilitri','centilitri','millilitri'))

# Un combobox (QComboBox) di nome 'UNIT' che permette di scegliere il tipo
#  di unita' di misura e deve contenere i seguenti items in quest'ordine:
#  'lunghezza', 'area', 'volume'.
layout_1 = QHBoxLayout()
layout_1.addWidget(QLabel('UNIT'))
combo_1 = QComboBox()
combo_1.setObjectName('UNIT')
layout_1.addWidget(combo_1)
combo_1.addItems(items)
'''combo_1.setObjectName('UNIT')
combo_1.insertItems(0,items)
combo_1.setCurrentIndex(0)
combo_1.insertItems(1,items)
combo_1.setCurrentIndex(1)
combo_1.insertItems(2,items)
combo_1.setCurrentIndex(2)'''

# Un campo (QLineEdit) di nome 'FROM_NUM' in cui l'utente puo' inserire il
#  numero che vuole convertire.
layout_1.addWidget(QLabel('FROM_NUM'))
campo = QLineEdit()
campo.setObjectName('FROM_NUM')
layout_1.addWidget(campo)
# Un combobox (QComboBox) di nome 'FROM_U' che permette di scegliere l'unita'
#  di misura del numero nel campo 'FROM_NUM'. Piu' avanti sono specificati gli
#  items di tale combobox.
layout_1 = QHBoxLayout()
layout_1.addWidget(QLabel('FROM_U'))
combo_2 = QComboBox()
combo_2.setObjectName('FROM_U')
layout_1.addWidget(combo_2)
#combo_2.addItems(units0)
# Un combobox (QComboBox) di nome 'TO_U' che permette di scegliere l'unita'
#  di misura a cui convertire. Piu' avanti sono specificati gli items di tale
#  combobox.
layout_1 = QHBoxLayout()
layout_1.addWidget(QLabel('TO_U'))
combo_3 = QComboBox()
combo_3.setObjectName('TO_U')
layout_1.addWidget(combo_3)
#combo_3.addItems(units0)
# Una label (QLabel) di nome 'TO_NUM' che visualizza il risultato della
#  conversione.
layout_1 = QHBoxLayout()
layout_1.addWidget(QLabel('TO_NUM'))
label_1 = QLabel()
label_1.setObjectName('TO_NUM')
layout_1.addWidget(label_1)

def insert_combo():
global unit
if combo_1.currentIndex():
combo_2 == units0
combo_3 == units0
elif  combo_1.currentIndex():
combo_2 == units1 
combo_3 == units1
elif  combo_1.currentIndex():
combo_2 == units2
combo_3 == units2
combo_1.activated.connect(insert_combo)
combo_2.activated.connect(insert_combo)
combo_3.activated.connect(insert_combo)
layout_2.addWidget(combo_1)
layout_2.addWidget(campo)
layout_2.addWidget(combo_2)
layout_2.addWidget(combo_3)
layout_2.addWidget(label_1)
window.setLayout(layout_2)
window.show()
# Fine implementazione dell'applicazione
# Non chiamare exec_(), la prossima chiamata esegue l'applicazione
runapp(globals())

Grazie

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 ---

'''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.