Primer širjenja po mreži

izris_sirjenja.py

import random
import matplotlib.pyplot as plt

random.seed(2020 + 1 + 4) # 2025

class Svet:
    def __init__(self, zacetno_stanje, verjetnost_okuzbe=0.42):
        self.mreza = zacetno_stanje
        self.generacija = 1
        self.sirina = len(self.mreza[0])
        self.visina = len(self.mreza)
        self.verjetnost_okuzbe = verjetnost_okuzbe

        self.stevilo_okuzenih = self.prestej_okuzene()

    def prestej_okuzene(self):
        """ Prešteje število okuženih v self.mreza
        """
        trenutno_okuzeni = 0
        # Z gnezdeno for zanko preštejemo vse, ki so večji ali enaki 0
        for v in range(self.visina):
            for s in range(self.sirina):
                if self.mreza[v][s] >= 0:
                    trenutno_okuzeni += 1

        return trenutno_okuzeni

    def procesiraj(self):
        # Nekaj naredimo z mrežo

        # Gremo čez vse točke
        # če je okužena dobimo sosede
        # z neko verjetnosto jih okužimo
        
        for v in range(self.visina):
            for s in range(self.sirina):
                if self.mreza[v][s] >= 0 and self.mreza[v][s] != self.generacija: # ta je okuzen
                    # dobimo sosede
                    
                    sosedi = self.dobi_sosede(v, s)
                    for sosed in sosedi: # [vrstica, stolpec]
                        if self.mreza[sosed[0]][sosed[1]] == -1:
                            # Ni okuzen
                            if random.random() < self.verjetnost_okuzbe:
                                self.mreza[sosed[0]][sosed[1]] = self.generacija
                                self.stevilo_okuzenih += 1
                            # Ce je okuzen -> Pustimo ga pri miru

        self.generacija += 1

    def dobi_sosede(self, v, s):
        """
        Dobi lokacije max 4 sosedov (gor, dol, levo, desno) 
        celice na mestu (v,s), 
        kjer celice ob robu nimajo sosedov, 
        ki jih ni na mreži
        """

        sosedi = []
        if v + 1 < self.visina: # Dol
            sosedi.append([v+1, s])
        if v - 1 >= 0: # Gor
            sosedi.append([v-1, s])
        if s + 1 < self.sirina: # Desno
            sosedi.append([v, s+1])
        if s - 1 >= 0: # Levo
            sosedi.append([v,s-1])
        
        return sosedi

    def izpisi_polje(self):
        for vrstica in self.mreza:
            print(vrstica)

VISINA = 100
SIRINA = 50
ST_KORAKOV = 70

# Tukaj inicializiramo
zacetno = []

for i in range(VISINA):
    zacetno.append([-1] * SIRINA)

zacetno[4][2] = 0
svet = Svet(zacetno, 0.4)
dnevi = [-1] 
seznam_novo_okuzenih = [0]
seznam_vseh_okuzenih = [svet.stevilo_okuzenih]

for korak in range(ST_KORAKOV):
    # Shranimo si del trenutnega stanja
    okuzenih_do_sedaj = svet.stevilo_okuzenih
    # poženemo simulacijo
    svet.procesiraj()
    # pogledamo spremembo
    stevilo_novo_okuzenih = svet.stevilo_okuzenih - okuzenih_do_sedaj
    print("Število okuženih:", svet.stevilo_okuzenih, ", novo okuženih je:", stevilo_novo_okuzenih)
    dnevi.append(korak)
    seznam_novo_okuzenih.append(stevilo_novo_okuzenih)
    seznam_vseh_okuzenih.append(svet.stevilo_okuzenih)

plt.plot(dnevi, seznam_vseh_okuzenih, label="p=0.4")

### Zacetek kopiranja

zacetno = []

for i in range(VISINA):
    zacetno.append([-1] * SIRINA)

zacetno[4][2] = 0
svet = Svet(zacetno, 0.9)
dnevi = [-1] 
seznam_novo_okuzenih = [0]
seznam_vseh_okuzenih = [svet.stevilo_okuzenih]

for korak in range(ST_KORAKOV):
    # Shranimo si del trenutnega stanja
    okuzenih_do_sedaj = svet.stevilo_okuzenih
    # poženemo simulacijo
    svet.procesiraj()
    # pogledamo spremembo
    stevilo_novo_okuzenih = svet.stevilo_okuzenih - okuzenih_do_sedaj
    print("Število okuženih:", svet.stevilo_okuzenih, ", novo okuženih je:", stevilo_novo_okuzenih)
    dnevi.append(korak)
    seznam_novo_okuzenih.append(stevilo_novo_okuzenih)
    seznam_vseh_okuzenih.append(svet.stevilo_okuzenih)

plt.plot(dnevi, seznam_vseh_okuzenih, label="p=0.9")


plt.xlabel("Dnevi")
# plt.ylabel("Število novo okuženih")
# plt.title("Število novo okuženih skozi čas")
### Konec kopiranja
plt.legend()
plt.savefig("graf_novih_okuzenih.png")

# svet.izpisi_polje()
print(svet.stevilo_okuzenih) # nekje med 0 in 4

plt.show()

izris_statistike.py

import random
import matplotlib.pyplot as plt
import numpy as np


random.seed(2020 + 1 + 4) # 2025

def kumulativne_vsote(seznam):
    if seznam == []:
        return []

    nov_seznam = [seznam[0]]
    for i in range(1, len(seznam)):
        nov_seznam.append(seznam[i] + nov_seznam[-1])

    return nov_seznam

class Svet:
    def __init__(self, zacetno_stanje, verjetnost_okuzbe=0.42):
        self.mreza = zacetno_stanje
        self.generacija = 1
        self.sirina = len(self.mreza[0])
        self.visina = len(self.mreza)
        self.verjetnost_okuzbe = verjetnost_okuzbe

        self.stevilo_okuzenih = self.prestej_okuzene()

    def prestej_okuzene(self):
        """ Prešteje število okuženih v self.mreza
        """
        trenutno_okuzeni = 0
        # Z gnezdeno for zanko preštejemo vse, ki so večji ali enaki 0
        for v in range(self.visina):
            for s in range(self.sirina):
                if self.mreza[v][s] >= 0:
                    trenutno_okuzeni += 1

        return trenutno_okuzeni

    def procesiraj(self):
        # Nekaj naredimo z mrežo

        # Gremo čez vse točke
        # če je okužena dobimo sosede
        # z neko verjetnosto jih okužimo
        
        novo_okuzenih = 0

        for v in range(self.visina):
            for s in range(self.sirina):
                if self.mreza[v][s] >= 0 and self.mreza[v][s] != self.generacija: # ta je okuzen
                    # dobimo sosede
                    
                    sosedi = self.dobi_sosede(v, s)
                    for sosed in sosedi: # [vrstica, stolpec]
                        if self.mreza[sosed[0]][sosed[1]] == -1:
                            # Ni okuzen
                            if random.random() < self.verjetnost_okuzbe:
                                self.mreza[sosed[0]][sosed[1]] = self.generacija

                                novo_okuzenih += 1
                            # Ce je okuzen -> Pustimo ga pri miru

        self.stevilo_okuzenih += novo_okuzenih
        
        self.generacija += 1

        return novo_okuzenih

    def simuliraj_korake(self, stevilo_korakov):
        
        novo_okuzeni = []
        
        # naredimo stevilo_korakov simulacije s pomočjo procesiraj in rezultat dodamo v 
        # novo okuzeni
        for korak in range(stevilo_korakov):
            novo_okuzeni.append(self.procesiraj())


        return novo_okuzeni

    def dobi_sosede(self, v, s):
        """
        Dobi lokacije max 4 sosedov (gor, dol, levo, desno) 
        celice na mestu (v,s), 
        kjer celice ob robu nimajo sosedov, 
        ki jih ni na mreži
        """

        sosedi = []
        if v + 1 < self.visina: # Dol
            sosedi.append([v+1, s])
        if v - 1 >= 0: # Gor
            sosedi.append([v-1, s])
        if s + 1 < self.sirina: # Desno
            sosedi.append([v, s+1])
        if s - 1 >= 0: # Levo
            sosedi.append([v,s-1])
        
        return sosedi

    def izpisi_polje(self):
        for vrstica in self.mreza:
            print(vrstica)


# To je izven class-a Svet, ker ne deluje direktno na njemu
def naredi_svet(visina, sirina, zacetne_okuzbe, verjetnost_okuzbe):
    mreza = []
    for i in range(visina):
        mreza.append([-1] * sirina)
    # Sezman zacetko okuzenih naj bo take oblike
    # sez = [ (1,2), (0,0), (10, 50), ...]
    for x,y in zacetne_okuzbe:
        mreza[x][y] = 0

    return Svet(mreza, verjetnost_okuzbe)


VISINA = 100
SIRINA = 50
ST_KORAKOV = 70


def narisi_graf_novo_okuzenih(mozne_verjetnosti = range(1, 11, 2)):
    # Za različne verjetnosti bomo izrasali grafe novo okuženih
    # -> [0.1, 0.2, 0.3, 0.4, .. 1.0]

    for moznost_okuzbe in mozne_verjetnosti:
        moznost_okuzbe /= 10 # +=, -= na isti princip
        # Naredimo svet
        svet = naredi_svet(VISINA, SIRINA, [(4,2)], moznost_okuzbe)

        # Poženemo svet
        seznam_novo_okuzenih = svet.simuliraj_korake(ST_KORAKOV)
        dnevi = range(len(seznam_novo_okuzenih))

        plt.plot(dnevi, seznam_novo_okuzenih, label="p="+str(moznost_okuzbe))

    plt.title("Novo okuženi")
    plt.savefig("graf_novih_okuzenih.png")
    plt.legend()
    plt.show()

def narisi_graf_vseh_okuzenih(mozne_verjetnosti = range(1, 11, 2)):
    # Za različne verjetnosti bomo izrasali grafe novo okuženih
    # -> [0.1, 0.2, 0.3, 0.4, .. 1.0]

    for moznost_okuzbe in mozne_verjetnosti:
        moznost_okuzbe /= 10 # +=, -= na isti princip
        # Naredimo svet
        svet = naredi_svet(VISINA, SIRINA, [(4,2)], moznost_okuzbe)

        # Poženemo svet
        seznam_novo_okuzenih = svet.simuliraj_korake(ST_KORAKOV)
        dnevi = range(len(seznam_novo_okuzenih))

        # Seznam novo okuzenih -> seznam vseh okuzenih
        seznam_vseh_okuzenih = kumulativne_vsote(seznam_novo_okuzenih)

        plt.plot(dnevi, seznam_vseh_okuzenih, label="p="+str(moznost_okuzbe))
    
    plt.title("Število vseh okuženih")
    plt.savefig("graf_vseh_okuzenih.png")
    plt.legend()
    plt.show()


# narisi_graf_novo_okuzenih()
narisi_graf_vseh_okuzenih()

izris_z_zemljevidom.py

import random
import matplotlib.pyplot as plt
import numpy as np

#<= x # Oboleli na dan x
# -1 Zdrav
# -2 Mrtev
# -3 Ozdravel
random.seed(2020 + 1 + 4 + 2) # 2025

# Obe funkciji sta dobri
def kumulativne_vsote(seznam):
    if seznam == []:
        return []

    nov_seznam = [seznam[0]]
    for i in range(1, len(seznam)):
        nov_seznam.append(seznam[i] + nov_seznam[-1])

    return nov_seznam

def kumulativna_vsota2(seznam):
    ime_seznama = []
    vsota = 0
    for element in seznam:
        vsota+=element
        ime_seznama.append(vsota)

    return ime_seznama

ZDRAVI_OSEBEK = -1
OZDRAVELI_OSEBEK = -2
MRTVI_OSEBEK = -3

class Rezultat:
    def __init__(self, novo_okuzeni, novo_ozdraveli, novo_umrli):
        self.novo_okuzeni = novo_okuzeni
        self.novo_ozdraveli = novo_ozdraveli
        self.novo_umrli = novo_umrli

class Svet:
    def __init__(self, zacetno_stanje, verjetnost_okuzbe=0.42, 
                 verjetnost_ozdravitve=0.1, verjetnost_smrti = 0.03):
        self.mreza = zacetno_stanje
        self.generacija = 1
        self.sirina = len(self.mreza[0])
        self.visina = len(self.mreza)
        
        self.verjetnost_okuzbe = verjetnost_okuzbe
        self.verjetnost_ozdravitve = verjetnost_ozdravitve
        self.verjetnost_smrti = verjetnost_smrti

        self.stevilo_okuzenih = self.prestej_okuzene()

    def prestej_okuzene(self):
        """ Prešteje število okuženih v self.mreza
        """
        trenutno_okuzeni = 0
        # Z gnezdeno for zanko preštejemo vse, ki so večji ali enaki 0
        for v in range(self.visina):
            for s in range(self.sirina):
                if self.mreza[v][s] >= 0:
                    trenutno_okuzeni += 1

        return trenutno_okuzeni

    def procesiraj(self):
        # Nekaj naredimo z mrežo

        # Gremo čez vse točke
        # če je okužena dobimo sosede
        # z neko verjetnosto jih okužimo
        
        novo_okuzenih = 0
        novo_ozdravelih = 0
        novo_umrlih = 0
        

        for v in range(self.visina):
            for s in range(self.sirina):
                if self.mreza[v][s] >= 0 and self.mreza[v][s] != self.generacija: # ta je okuzen
                    
                    # Najprej okužimo ostale
                    # dobimo sosede
                    sosedi = self.dobi_sosede(v, s)
                    for sosed in sosedi: # [vrstica, stolpec]
                        if self.mreza[sosed[0]][sosed[1]] == ZDRAVI_OSEBEK:
                            # Ni okuzen
                            if random.random() < self.verjetnost_okuzbe:
                                self.mreza[sosed[0]][sosed[1]] = self.generacija

                                novo_okuzenih += 1
                            # Ce je okuzen -> Pustimo ga pri miru

                    # Mogoče ozdravimo
                    if random.random() < self.verjetnost_ozdravitve:
                        # Ne morem se več okužiti
                        self.mreza[v][s] = OZDRAVELI_OSEBEK
                        novo_ozdravelih += 1
                    elif random.random() < self.verjetnost_smrti:
                        self.mreza[v][s] = MRTVI_OSEBEK
                        novo_umrlih += 1

        self.stevilo_okuzenih += novo_okuzenih - novo_ozdravelih - novo_umrlih
        
        self.generacija += 1

        return Rezultat(novo_okuzenih, novo_ozdravelih, novo_umrlih)

    def simuliraj_korake(self, stevilo_korakov):
        
        novo_okuzeni = []
        
        # naredimo stevilo_korakov simulacije s pomočjo procesiraj in rezultat dodamo v 
        # novo okuzeni
        for korak in range(stevilo_korakov):
            novo_okuzeni.append(self.procesiraj())


        return novo_okuzeni

    def dobi_sosede(self, v, s):
        """
        Dobi lokacije max 4 sosedov (gor, dol, levo, desno) 
        celice na mestu (v,s), 
        kjer celice ob robu nimajo sosedov, 
        ki jih ni na mreži
        """

        sosedi = []
        if v + 1 < self.visina: # Dol
            sosedi.append([v+1, s])
        if v - 1 >= 0: # Gor
            sosedi.append([v-1, s])
        if s + 1 < self.sirina: # Desno
            sosedi.append([v, s+1])
        if s - 1 >= 0: # Levo
            sosedi.append([v,s-1])
        
        return sosedi

    def izpisi_polje(self):
        for vrstica in self.mreza:
            print(vrstica)


# To je izven class-a Svet, ker ne deluje direktno na njemu
def naredi_svet(visina, sirina, zacetne_okuzbe, verjetnost_okuzbe):
    mreza = []
    for i in range(visina):
        mreza.append([ZDRAVI_OSEBEK] * sirina)
    # Sezman zacetko okuzenih naj bo take oblike
    # sez = [ (1,2), (0,0), (10, 50), ...]
    for x,y in zacetne_okuzbe:
        mreza[x][y] = 0

    return Svet(mreza, verjetnost_okuzbe)


VISINA = 100
SIRINA = 50
ST_KORAKOV = 100


def narisi_graf_novo_okuzenih(mozne_verjetnosti = range(1, 11, 3)):
    # Za različne verjetnosti bomo izrasali grafe novo okuženih
    # -> [0.1, 0.3, 0.5, 0.7, 0.9]

    for moznost_okuzbe in mozne_verjetnosti:
        
        moznost_okuzbe /= 10 # +=, -= na isti princip
        print(moznost_okuzbe)
        # Naredimo svet
        svet = naredi_svet(VISINA, SIRINA, [(4,2)], moznost_okuzbe)
        
        # Poženemo svet
        seznam_rezultatov = svet.simuliraj_korake(ST_KORAKOV) 

        seznam_novo_okuzenih = []
        seznam_novo_ozdravelih = []

        for rezultat in seznam_rezultatov:
            seznam_novo_okuzenih.append(rezultat.novo_okuzeni)
            seznam_novo_ozdravelih.append(rezultat.novo_ozdraveli)


        dnevi = range(len(seznam_novo_okuzenih))

        plt.plot(dnevi, seznam_novo_okuzenih, label="p="+str(moznost_okuzbe))
        #plt.plot(dnevi, seznam_novo_ozdravelih, label="p=" + str(moznost_okuzbe) + " ozdraveli")

    plt.title("Novo okuženi")
    plt.savefig("graf_novih_okuzenih.png")
    plt.legend()
    plt.show()

def narisi_graf_vseh_okuzenih(mozne_verjetnosti = range(1, 11, 2)):
    # Za različne verjetnosti bomo izrasali grafe novo okuženih
    # -> [0.1, 0.2, 0.3, 0.4, .. 1.0]

    for moznost_okuzbe in mozne_verjetnosti:
        moznost_okuzbe /= 10 # +=, -= na isti princip
        # Naredimo svet
        svet = naredi_svet(VISINA, SIRINA, [(4,2)], moznost_okuzbe)

        # Poženemo svet
        seznam_rezultatov = svet.simuliraj_korake(ST_KORAKOV)

        seznam_novo_okuzenih = []
        for rezultat in seznam_rezultatov:
            seznam_novo_okuzenih.append(rezultat.novo_okuzeni)

        dnevi = range(len(seznam_novo_okuzenih))

        # Seznam novo okuzenih -> seznam vseh okuzenih
        seznam_vseh_okuzenih = kumulativne_vsote(seznam_novo_okuzenih)
        plt.plot(dnevi, seznam_vseh_okuzenih, label="p="+str(moznost_okuzbe))
    
    plt.title("Število vseh okuženih")
    plt.savefig("graf_vseh_okuzenih.png")
    plt.legend()
    plt.show()


def narisi_graf_vseh_podatkov(p_o, p_s, p_ozdr):
    svet = naredi_svet(VISINA, SIRINA, [(4,2), (70, 30)], p_o)

    seznam_rezultatov = svet.simuliraj_korake(ST_KORAKOV)

    seznam_novo_okuzenih = []
    seznam_novo_ozdravelih = []
    seznam_novo_umrlih = []
    seznam_nekuzenih = [svet.visina*svet.sirina]

    for rezultat in seznam_rezultatov:
        seznam_novo_okuzenih.append(rezultat.novo_okuzeni)
        seznam_novo_ozdravelih.append(rezultat.novo_ozdraveli)
        seznam_novo_umrlih.append(rezultat.novo_umrli)
        seznam_nekuzenih.append(seznam_nekuzenih[-1] - rezultat.novo_okuzeni - 
                                rezultat.novo_ozdraveli - rezultat.novo_umrli)


    dnevi = range(len(seznam_rezultatov))
    # Narišemo zemljevid
    plt.imshow(svet.mreza)
    plt.show()

    plt.plot(dnevi, kumulativne_vsote(seznam_novo_okuzenih), label="skupno okuženi")
    plt.plot(dnevi, kumulativne_vsote(seznam_novo_ozdravelih), label="skupno ozdraveli")
    plt.plot(dnevi, kumulativne_vsote(seznam_novo_umrlih), label="Skupno umrli")
    plt.plot(dnevi, seznam_nekuzenih[1:], label="Skupno neokuženi")

    plt.legend()
    plt.show()

#narisi_graf_novo_okuzenih()
#narisi_graf_vseh_okuzenih()

narisi_graf_vseh_podatkov(0.42, 0.1, 0.03)

sirjenje.py

from collections import deque

VISINA = 10
SIRINA = 5

# Polje okuzenih
polje = []
# smer iz katere je bil clovek okuzen
# 5 -> 6  je "L"
izvor = [] # " ", "U", "D", "L", "R"

for i in range(VISINA):
    vrstica = []
    vrstica_izvora = []
    for j in range(SIRINA):
        vrstica.append(-1)
        vrstica_izvora.append(" ")
    izvor.append(vrstica_izvora)
    polje.append(vrstica)

def izpisi_polje(polje_za_izpis):
    for vrstica in polje_za_izpis:
        print(vrstica)

def okuzi_sosede(v, s):
    moj_dan = polje[v][s]
    novi_okuzeni = []
    # Gremo cez vse sosede, ce to lahko storimo
    # Dol
    if v+1 < VISINA and polje[v+1][s] == -1:
        polje[v+1][s] = moj_dan + 1
        izvor[v+1][s] = "U" 
        novi_okuzeni.append([v+1, s])
    # Gor
    if v-1 >= 0 and polje[v-1][s] == -1:
        polje[v-1][s] = moj_dan + 1
        novi_okuzeni.append([v-1, s])
    # Levo 
    if s - 1 >= 0 and polje[v][s-1] == -1:
        polje[v][s-1] = moj_dan + 1
        novi_okuzeni.append([v, s-1])
    # Desno
    if s + 1 < SIRINA and polje[v][s+1] == -1:
        polje[v][s+1] = moj_dan + 1
        novi_okuzeni.append([v, s+1])
    return novi_okuzeni

# Ta posebna vrsta
cakajoci = deque()

polje[2][3] = 0
cakajoci.append([2,3])

polje[-2][0] = -2
polje[-2][1] = -2
polje[-2][2] = -2
polje[-2][3] = -2


while len(cakajoci) > 0:
    na_vrsti = cakajoci.popleft()
    v,s = na_vrsti

    novi = okuzi_sosede(v, s)

    for novo_okuzeni in novi:
        cakajoci.append(novo_okuzeni)

izpisi_polje(polje)

sirjenje_verjetnost.py

import random

class Svet:
    def __init__(self, zacetno_stanje, verjetnost_okuzbe=0.42):
        self.mreza = zacetno_stanje
        self.generacija = 1
        self.sirina = len(self.mreza[0])
        self.visina = len(self.mreza)
        self.verjetnost_okuzbe = verjetnost_okuzbe

    def procesiraj(self):
        # Nekaj naredimo z mrežo

        # Gremo čez vse točke
        # če je okužena dobimo sosede
        # z neko verjetnosto jih okužimo
        
        for v in range(self.visina):
            for s in range(self.sirina):
                if self.mreza[v][s] >= 0 and self.mreza[v][s] != self.generacija: # ta je okuzen
                    # dobimo sosede
                    
                    sosedi = self.dobi_sosede(v, s)
                    for sosed in sosedi: # [vrstica, stolpec]
                        if self.mreza[sosed[0]][sosed[1]] == -1:
                            # Ni okuzen
                            if random.random() < self.verjetnost_okuzbe:
                                self.mreza[sosed[0]][sosed[1]] = self.generacija
                            # Ce je okuzen -> Pustimo ga pri miru

        self.generacija += 1

    def dobi_sosede(self, v, s):
        """
        Dobi lokacije max 4 sosedov (gor, dol, levo, desno) 
        celice na mestu (v,s), 
        kjer celice ob robu nimajo sosedov, 
        ki jih ni na mreži
        """

        sosedi = []
        if v + 1 < self.visina: # Dol
            sosedi.append([v+1, s])
        if v - 1 >= 0: # Gor
            sosedi.append([v-1, s])
        if s + 1 < self.sirina: # Desno
            sosedi.append([v, s+1])
        if s - 1 >= 0: # Levo
            sosedi.append([v,s-1])
        
        return sosedi


    def izpisi_polje(self):
        for vrstica in self.mreza:
            print(vrstica)

VISINA = 10
SIRINA = 5

zacetno = []

for i in range(VISINA):
    zacetno.append([-1] * SIRINA)

zacetno[4][2] = 0

svet = Svet(zacetno)



svet.procesiraj()

svet.izpisi_polje()

sirjenje_z_izrisom.py

import random
import matplotlib.pyplot as plt

random.seed(2020 + 1 + 4) # 2025

class Svet:
    def __init__(self, zacetno_stanje, verjetnost_okuzbe=0.42):
        self.mreza = zacetno_stanje
        self.generacija = 1
        self.sirina = len(self.mreza[0])
        self.visina = len(self.mreza)
        self.verjetnost_okuzbe = verjetnost_okuzbe

        self.stevilo_okuzenih = self.prestej_okuzene()

    def prestej_okuzene(self):
        """ Prešteje število okuženih v self.mreza
        """
        trenutno_okuzeni = 0
        # Z gnezdeno for zanko preštejemo vse, ki so večji ali enaki 0
        for v in range(self.visina):
            for s in range(self.sirina):
                if self.mreza[v][s] >= 0:
                    trenutno_okuzeni += 1

        return trenutno_okuzeni

    def procesiraj(self):
        # Nekaj naredimo z mrežo

        # Gremo čez vse točke
        # če je okužena dobimo sosede
        # z neko verjetnosto jih okužimo
        
        for v in range(self.visina):
            for s in range(self.sirina):
                if self.mreza[v][s] >= 0 and self.mreza[v][s] != self.generacija: # ta je okuzen
                    # dobimo sosede
                    
                    sosedi = self.dobi_sosede(v, s)
                    for sosed in sosedi: # [vrstica, stolpec]
                        if self.mreza[sosed[0]][sosed[1]] == -1:
                            # Ni okuzen
                            if random.random() < self.verjetnost_okuzbe:
                                self.mreza[sosed[0]][sosed[1]] = self.generacija
                                self.stevilo_okuzenih += 1
                            # Ce je okuzen -> Pustimo ga pri miru

        self.generacija += 1

    def dobi_sosede(self, v, s):
        """
        Dobi lokacije max 4 sosedov (gor, dol, levo, desno) 
        celice na mestu (v,s), 
        kjer celice ob robu nimajo sosedov, 
        ki jih ni na mreži
        """

        sosedi = []
        if v + 1 < self.visina: # Dol
            sosedi.append([v+1, s])
        if v - 1 >= 0: # Gor
            sosedi.append([v-1, s])
        if s + 1 < self.sirina: # Desno
            sosedi.append([v, s+1])
        if s - 1 >= 0: # Levo
            sosedi.append([v,s-1])
        
        return sosedi

    def izpisi_polje(self):
        for vrstica in self.mreza:
            print(vrstica)

VISINA = 100
SIRINA = 50
ST_KORAKOV = 70

# Tukaj inicializiramo
zacetno = []

for i in range(VISINA):
    zacetno.append([-1] * SIRINA)

zacetno[4][2] = 0
svet = Svet(zacetno, 0.4)
dnevi = [-1] 
seznam_novo_okuzenih = [0]
seznam_vseh_okuzenih = [svet.stevilo_okuzenih]

for korak in range(ST_KORAKOV):
    # Shranimo si del trenutnega stanja
    okuzenih_do_sedaj = svet.stevilo_okuzenih
    # poženemo simulacijo
    svet.procesiraj()
    # pogledamo spremembo
    stevilo_novo_okuzenih = svet.stevilo_okuzenih - okuzenih_do_sedaj
    print("Število okuženih:", svet.stevilo_okuzenih, ", novo okuženih je:", stevilo_novo_okuzenih)
    dnevi.append(korak)
    seznam_novo_okuzenih.append(stevilo_novo_okuzenih)
    seznam_vseh_okuzenih.append(svet.stevilo_okuzenih)

plt.plot(dnevi, seznam_vseh_okuzenih, label="p=0.4")

### Zacetek kopiranja
random.seed(2020 + 1 + 5)
zacetno = []

for i in range(VISINA):
    zacetno.append([-1] * SIRINA)

zacetno[4][2] = 0
svet = Svet(zacetno, 0.4)
dnevi = [-1] 
seznam_novo_okuzenih = [0]
seznam_vseh_okuzenih = [svet.stevilo_okuzenih]

for korak in range(ST_KORAKOV):
    # Shranimo si del trenutnega stanja
    okuzenih_do_sedaj = svet.stevilo_okuzenih
    # poženemo simulacijo
    svet.procesiraj()
    # pogledamo spremembo
    stevilo_novo_okuzenih = svet.stevilo_okuzenih - okuzenih_do_sedaj
    print("Število okuženih:", svet.stevilo_okuzenih, ", novo okuženih je:", stevilo_novo_okuzenih)
    dnevi.append(korak)
    seznam_novo_okuzenih.append(stevilo_novo_okuzenih)
    seznam_vseh_okuzenih.append(svet.stevilo_okuzenih)

plt.plot(dnevi, seznam_vseh_okuzenih, label="p=0.9")


plt.xlabel("Dnevi")
# plt.ylabel("Število novo okuženih")
# plt.title("Število novo okuženih skozi čas")
### Konec kopiranja
plt.legend()
plt.savefig("graf_novih_okuzenih.png")

# svet.izpisi_polje()
print(svet.stevilo_okuzenih) # nekje med 0 in 4

plt.show()