kep=[]          # ez lesz a 3 dimenziós mátrix
                # ---> egy képpont elérése: kep[i][j]---> [r,g,b]
                # ---> azon belül R=kep[i][j][0], G=kep[i][j][1], B=kep[i][j][2]

def F1():
    fbe=open('kep.txt','r')
    #mátrix felépítése: olyan lista, melynek elemei LISTÁKBÓ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(sor[p:p+3])
        kep.append(egy_sor)
            
    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
    RGB=kep[sor][oszlop]    # az adott sor és oszlop indexen egy 3 elemű lista van (RGB)
    R=RGB[0]
    G=RGB[1]
    B=RGB[2]
    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 3 elemű listák, ugye:
    for kepsor in kep:
        for keppont in kepsor:
            if sum(keppont)>600:           # a listára alkalmazható a sum függvény
                vk+=1
    print(f'A világos képpontok száma: {vk}')       # 7837

def kulcsfuggveny(keppont):     # rendezéses minimumkereséshez kell...
    return sum(keppont)

def F4():
    print('4. feladat')
    # ELSŐ KÖRBEN klasszikus minimumkeresés az RGB összegek között
    minimum=255*3    # ez a maximális RGB összeg, így biztos lesz nála kisebb!
    # kep mátrix 2D bejárása, az elemei 3 elemű listák, ugye:
    for kepsor in kep:
        for keppont in kepsor:
            if sum(keppont)<minimum:
                minimum=sum(keppont)

    # Vagy minimumkiválasztás rendezéssel:
    rendezett=sorted([sorted(kepsor,key=kulcsfuggveny) for kepsor in kep],key=lambda x: kulcsfuggveny(x[0]))
    minimum=sum(rendezett[0][0])
    
    # MÁSODIK KÖRBEN szedjük össze a minimummal egyező képpontokat:
    minimumok=[]    # egy biztos lesz...
    for kepsor in kep:
        for keppont in kepsor:
            if sum(keppont)==minimum:
                minimumok.append(keppont)          # minimumok listába beletesszük a mátrix elemét
                
    print(f'A legsötétebb pont RGB összege: {minimum}')     # 197
    print('A legsötétebb pixelek színe:')
    for RGB in minimumok:       # RGB egy három elemű lista...
        print(f'RGB({RGB[0]},{RGB[1]},{RGB[2]})')           # RGB(0,85,112)  RGB(0,86,111)  RGB(0,86,111)

def hatar(s,d):     # 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
    keppontok_egy_sorban=kep[s]        # ez egy lista, melynek elemei számhármasok, ugye...
    # tudjuk, hogy egy sorban 640 képpont van, azaz 640 számhármas (RGB), -1 azért, hogy i. és i+1. képpontot nézhessük
    for i in range(640-1):
        if abs(keppontok_egy_sorban[i][2]-keppontok_egy_sorban[i+1][2])>d:      # 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()