# a keppont osztály egy listából "építkezik" (lst),
# mely egy RGB számhármas (lsd. 32. sor!)
class keppont:
    def __init__(self,lst):     
        self.r=lst[0]
        self.g=lst[1]
        self.b=lst[2]

    def osszeg(self):
        return self.r+self.g+self.b

    def vilagos(self):
        if keppont.osszeg(self)>600:
            return True
        return False
#-------------------------------------------------------------------------------------------
# JELÖLÉS:  "ko" az alábbi részekben egy keppont class-ba tartozó objektumot fog jelölni,   |
#           (röviden: "ko" egy keppont objektum)                                            |
#-------------------------------------------------------------------------------------------
    
kep=[]          # ez lesz a 2 dimenziós mátrix
                # ---> egy képpont elérése: kep[i][j]---> keppont objektum
                # ---> azon belül R=kep[i][j].r, G=kep[i][j].g, B=kep[i][j].b

def F1():
    fbe=open('kep.txt','r')
    # mátrix felépítése: olyan lista, melynek elemei OBJEKTUMOKBÓL álló listák
    for sor in fbe:
        sor=list(map(int,sor.strip().split()))  # minden integer (egész szám) legyen
        # egy sor 640x3 számot tartalmaz, ezeket kell hármasával "csoportosítani"
        egy_sor=[]
        for p in range(0,640*3,3):      # p - pixel (képpont)
            egy_sor.append(keppont(sor[p:p+3]))     # itt "generálom" a keppont objektumokat
        kep.append(egy_sor)                         # egy_sor egy ko (objektum) lista
            
    fbe.close()
    # print(kep) - ennek a végrehajtása több, mint egy percig tartott a gépemen, pedig nem rossz gép:
    # Intel(R) Core(TM) i5-9400F CPU @ 2.90GHz, 16GB RAM
    # utána az ablak bezárása majdnem kifagyáshoz vezetett, de aztán mégsem... :)

def F2():
    print('2. feladat:')
    print('Kérem egy képpont adatait!')
    sor=int(input('Sor: '))-1                       # 180    -1 az indexelés miatt!!!
    oszlop=int(input('Oszlop: '))-1                 # 320
    ko=kep[sor][oszlop]     # az adott sor és oszlop indexen egy keppont objektum van, ugye...
    R=ko.r                
    G=ko.g
    B=ko.b
    print(f'A képpont színe RGB({R},{G},{B})')      # RGB(184,183,181)

def F3():
    print('3. feladat:')
    # világos képpont: RGB-értékeinek összege 600-nál nagyobb    
    vk=0
    # kep mátrix 2D bejárása, az elemei keppont objektumok, ugye:
    for kepsor in kep:
        for ko in kepsor:
            if ko.vilagos():           # alkalmazható az objektum "vilagos" metódusa (modulja)
                vk+=1
    print(f'A világos képpontok száma: {vk}')       # 7837

def kulcsfuggveny(ko):
    return ko.osszeg()

def F4():
    print('4. feladat')
    # ELSŐ KÖRBEN minimumkeresés az RGB összegek között rendezéssel
    rendezett=sorted([sorted(kepsor,key=kulcsfuggveny) for kepsor in kep],key=lambda x: kulcsfuggveny(x[0]))   
    minimum=rendezett[0][0].osszeg()
    print(f'A legsötétebb pont RGB összege: {minimum}')     # 197

    # MÁSODIK KÖRBEN szedjük össze a minimummal egyező képpontokat:
    minimumok=[]    # egy biztos lesz...
    for kepsor in kep:
        for ko in kepsor:
            if ko.osszeg()==minimum:
                minimumok.append(ko)    # minimumok listába beletesszük a mátrix elemét, a ko-t
                
    print('A legsötétebb pixelek színe:')
    for ko in minimumok:       # minimumok egy ko-kat tartalmazó lista
        print(f'RGB({ko.r},{ko.g},{ko.b})')           # RGB(0,85,112)  RGB(0,86,111)  RGB(0,86,111)

def hatar(s,diff):     # paraméterek: s ---> sor, d ---> eltérés
    # egy adott sorban van-e olyan hely, ahol az egymás melletti képpontok 
    # kék színösszetevőinek eltérése meghalad egy adott értéket (diff)

    kok_egy_sorban=kep[s]   # ez egy lista, melynek elemei "ko"-k (kok), azaz keppont objektumok, ugye...

    # tudjuk, hogy egy sorban 640 képpont van, azaz 640 ko, -1 azért, hogy i. és i+1. képpontot nézhessük
    for i in range(640-1):
        if abs(kok_egy_sorban[i].b-kok_egy_sorban[i+1].b)>diff:      # i. és i+1. képpont
            return True     # ha találunk ilyen helyet, akkor True-t ad vissza a függvény (és itt le is áll)
    return False            # ha mégsem állt le, akkor False értéket ad vissza a függvény
            
def F6():
    print('6. feladat')
    differencia=10
    # legfelső sor keresése:                        # első sortól előre...
    sor=0
    while not hatar(sor,differencia):
        sor+=1
    print(f'A felhő legfelső sora: {sor+1}')        # 103   (+1 indexelés és a sorszám közötti különbség)
    # legalsó sor keresése:                         # utolsó sortól visszafelé...
    sor=360-1       # indexelés, ugye...
    while not hatar(sor,differencia):
        sor-=1
    print(f'A felhő legalsó sora: {sor+1}')         # 280   (+1 indexelés és a sorszám közötti különbség)
    
# -------------------------------------------------------------------------------------------------------------------------
F1()
F2()
F3()
F4()

F6()