Programacion para la Integracion de sistemas

 Autor : René Curín

Competencia : Trabajo autónomo

Asignatura: Programacion para la Integracion de sistemas
Palabras claves: Python, Pygame, Simulación

¿Se han preguntado como funcionan los mapas en los videojuegos 2D?. La verdad no es tan fácil como parece, pero no hay que preocuparse, porque aprender en un lenguaje como python, simple y potente, siempre es divertido.

Descripción de la actividad 

El proyecto que se realizo en esta actividad consistio en la creacion y simulacion de un videojuego, la idea principal es que los movimientos de los personajes sea de ,anera autonoma, es decir, que se mueven de manera aleatoria por todo el mapa, y ademas crear una interfaz que muestre la sonde (personaje) en todo momento.

Enunciado de la actividad:

En este proyecto usted debera programar y simular un sistema de monitoreo y control de sondas robot que se mueven en un planeta desconocido. Existen 4 sondas, las cuales navegan de manera automatica por un mapa 2D. Para el manejo de sondas se propone la siguiente estructura de datos: nld: id de la sonda, nX, nY: Coordenadas de la sonda de el mapa 2D, Cxd, Cyd: Direccion ortogonal (-1,0,+1), nVelo: Velocidad de la sonda [1,2,3], nRango: Numero de pasos a mover, aSensor: Vector de 5 elementos de tipo entero [O,C,N,H], nFig: Sprote animado, nTime y nTime2: Contadores, IFlag1 y IFlag2: Banderas logicas.

Desarrollo de la actividad:

  Estrategia de trabajo; Pensar y encontrar los elementos que necesitariamos para poder emplear el proyecto, tales como posibles funciones, clases, imagenes, movimientos, dimenciones de pantalla etc

  Modelo de solucion; Comenzamos por separar todo los objetos en clases independientes, tales como el personaje, el mapa, las superficies de vista, las baterias, y luego crear un objeto de todo lo que se necesitara.

. 

Codigo Fuente

 import pygame, sys, ctypes, random
from pygame.locals import *

ANCHO = 640
LARGO = 480

Mapa = (2560, 1440)

Panel = (96, 96)

def fuentes(text,size):
    fuente = pygame.font.Font(None, size)
    texto1 = fuente.render(text, 0, (255, 255, 255))
    return texto1

def Load_Image(sFile, transp = False):
    try: image = pygame.image.load(sFile)
    except pygame.error, message:
        raise SystemExit, message
    image = image.convert()
    if transp:
       color = image.get_at((0, 0))
       image.set_colorkey(color, RLEACCEL)
    return image

class eSonda(ctypes.Structure):
    __fields__ = [
                  ("nId", ctypes.c_int), ("nX", ctypes.c_int), ("nY", ctypes.c_int), ("Cxd", ctypes.c_int),
                  ("Cyd", ctypes.c_int), ("nVelo", ctypes.c_int), ("nRango", ctypes.c_int), ("nFig", ctypes.c_char),
                  ("aSensor", ctypes.c_int), ("nTime1", ctypes.c_int), ("nTime2", ctypes.c_int), ("IFlag1", ctypes.c_bool), ("IFlag2", ctypes.c_bool)
                 ]

class eBaldosa(ctypes.Structure):
    __fields__ = [("Fig", ctypes.c_char), ("Oxigeno", ctypes.c_int), ("Carbono", ctypes.c_int), ("Nitrogeno", ctypes.c_int), ("Hidrogeno", ctypes.c_int)]

def load_sonda(sonda):
    for i in range(0,4):
        sonda[i].nId = i + 1                     
        sonda[i].nX = random.randint(0,2528)     
        sonda[i].nY = random.randint(0,1408)        #Coordenada Y en el mapa
        sonda[i].Cxd = 0
        sonda[i].Cyd = 0
        sonda[i].Nvelo = random.randint(1,40)     
        sonda[i].nRago = random.randint(1,10)     
        sonda[i].nFig = "sondas/s"+str(i)+".png"
        sonda[i].aSensor = [0, 0, 0, 0, 0]        
        sonda[i].nTime1 = 0                       
        sonda[i].nTime2 = 0                       
        sonda[i].IFlag1 = False                   
        sonda[i].IFlag2 = False                    

def load_bal(baldosa):
    for i in range(0, 13):
        baldosa[i].Fig = "tiles/"+str(i)+".png"       
        baldosa[i].Oxigeno = random.randint(0, 100)    
        baldosa[i].Carbono = random.randint(0, 100)    
        baldosa[i].Nitrogeno = random.randint(0, 100)  
        baldosa[i].Hidrogeno = random.randint(0, 100)  
    return

class new_mapa(pygame.surface.Surface):
    def __init__(self, baldosas, m_size):  
        self.baldosas = baldosas           
        self.grilla = self.get_malla()     
        self.imagenes = self.load_images() 
        self.s1 = pygame.Surface(m_size)
        self.mapa = self.load_mapa()
        self.rect = self.s1.get_rect()
        self.rect.move_ip(0, 0)

    def load_mapa(self):                   
        x = 0
        y = 0

        malla_img = self.grilla
        img_bal = self.imagenes
        for i in range(45):
            for j in range(80):
                num = malla_img[i][j]
                m = img_bal[num]
                self.s1.blit(m, (x, y))
                x += 32
            y += 32
            x = 0

    def grilla_imagenes_(self):
        malla_img = self.grilla
        bal = self.baldosas
        grilla_images = [0] * 80
        for i in range(45):
            grilla_images[i] = [0] * 80
        for f in range(45):
            for c in range(80):
                bal[malla_img[f][c]]
                grilla_images[f][c] = bal[malla_img[f][c]]
                grilla_images[f][c].Oxigeno = random.randint(0,100)
                grilla_images[f][c].Carbono = random.randint(0,100)
                grilla_images[f][c].Nitrogeno = random.randint(0,100)
                grilla_images[f][c].Hidrogeno = random.randint(0,100)
        return grilla_images


    def get_malla(self):         
        malla = [0] * 80
        for i in range(45):
            malla[i] = [0] * 80

        for f in range(45):
            for c in range(80):
                p = random.randint(0, 12)
                malla[f][c] = p
        return malla

    def load_images(self):        
        images = []
        for p in range(0,13):
            images.append(Load_Image(self.baldosas[p].Fig, True))
        return images

    def scroll(self):
        Mx, My = pygame.mouse.get_pos()

        x = 0
        y = 0
        if Mx < 100:
            x += 8
        if Mx > 540:
            x -= 8
        if My < 100:
            y += 8
        if My > 380:
            y -= 8

        self.rect.move_ip(x, y)

    def update(self, screen):
        if self.rect.x > 0:
            self.rect.x = 0
        if self.rect.x < -1920:
            self.rect.x = -1920
        if self.rect.y > 0:
            self.rect.y = 0
        if self.rect.y < -960:
            self.rect.y = -960
        screen.blit(self.s1, (self.rect.x, self.rect.y))

class Sondas_Automatas(pygame.surface.Surface):
    def __init__(self, mapa, sonda):
        self.sonda = sonda
        self.image = Load_Image(self.sonda.nFig,True)
        self.rect = self.image.get_rect()
        self.mapa = mapa
        self.rect.move_ip(self.sonda.nX, self.sonda.nY)
        self.s_sonda = pygame.Surface((90,90))
        self.cuadros = 0
        self.distancia = 0
        self.bateria = 100
        self.bateria_send = 0
        self.vel()
        self.bateria_S()
        self.carga = 10000

    def bateria_S(self):
        self.cuadros = self.distancia / 32
        if self.cuadros > 2:
            self.bateria -= 1
            self.bateria_send += 1
            self.distancia = 0

    def vel(self):
        self.sonda.Nvelo = random.randint(1,3)
        self.sonda.Cxd = random.randint(-2,2)
        self.sonda.Cyd = random.randint(-2,2)

        self.sonda.nRango =  random.randint(0,5) * 32
        self.cont = 0

        nDir = random.randint(1,5)
        if nDir == 1: # Norte ?
           self.sonda.Cxd = 0 ; self.sonda.Cyd = self.sonda.Cxd
        if nDir == 2: # Este ?
           self.sonda.Cxd = self.sonda.Cxd  ; self.sonda.Cyd = 0
        if nDir == 3: # Sur ?
           self.sonda.Cxd = 0 ; self.sonda.Cyd = self.sonda.Cyd
        if nDir == 4: # Oeste ?
           self.sonda.Cxd = self.sonda.Cxd; self.sonda.Cyd = 0

    def mover(self):
        self.bateria_S()
        self._x = self.sonda.Cxd * self.sonda.Nvelo
        self._y = self.sonda.Cyd * self.sonda.Nvelo
        self.cont += 0.1
        if self.bateria <= 0:
            distancia = 0
            self.cargar_batery()
        if self._x == 0 and self._y > 0:
            self.distancia += 1
        elif self._x > 0 and self._y == 0:
            self.distancia += 1
        elif self._x > 0 and self._y > 0:
            self.distancia += 1
        if self.cont > self.sonda.nRango:
            self.vel()

        self.rect.move_ip(self._x,self._y)

    def cargar_batery(self):
        self._x = 0
        self._y = 0
        self.cuadros = 0
        self.carga -= 1
        if self.carga % 100 == 0:
            self.bateria_send -= 1
        if self.bateria_send == 0:
            self.bateria = 100

    def update(self,screen):
        if self.rect.x < 0:
            self.sonda.Cxd = - self.sonda.Cxd
        if self.rect.x > 2560-32:
            self.sonda.Cxd = - self.sonda.Cxd
        if self.rect.y < 0:
            self.sonda.Cyd = - self.sonda.Cyd
        if self.rect.y > 1440-32:
            self.sonda.Cyd = - self.sonda.Cyd
        screen.blit(self.image,(self.rect.x + self.mapa.rect.x, self.rect.y + self.mapa.rect.y))

class S_panel(pygame.surface.Surface):
    def __init__(self, s_auto,mapa,superficie):
        self.s_auto = s_auto               
        self.super_f = superficie          
        self.mapa = mapa                   
        self.image_sonda = self.s_auto.image
        self.super_bateria = pygame.Surface((58,40)) 
        self.super_nivelesQ = pygame.Surface((58,42))
        self.super_total = pygame.Surface((160,100)) 
        self.super_total.fill((255,255,255))         
        self.super_texto = pygame.Surface((58,13))
        self.text_niveles_Q()                        
        self.superficie = self.super_niveles_Q()     
        self.grilla = self.mapa.grilla
        self.grilla_images = self.mapa.grilla_imagenes_()
        self.batery_image = pygame.transform.scale(Load_Image("images/b2.png",True),(22,35))
        self.super_hide = pygame.Surface((15,26))
        self.super_hide2 = pygame.Surface((22,35))

    def mostrar(self):
        self.super_f.fill((0,0,0))      #Fondo del mini mapa, color negro
        self.super_f.blit(self.mapa.s1,(-self.s_auto.rect.x+32,-self.s_auto.rect.y+32))     #Mapa del minimapa
        self.super_f.blit(self.s_auto.image,(32,32))        #Nave del minimapa
        self.niveles_Q()
        self.batery()

    def text_niveles_Q(self):
        O = fuentes("O", 15)
        C = fuentes("C", 15)
        H = fuentes("H", 15)
        N = fuentes("N", 15)
        self.super_texto.blit(O,(1,2))
        self.super_texto.blit(C,(15,2))
        self.super_texto.blit(H,(30,2))
        self.super_texto.blit(N,(45,2))

    def super_niveles_Q(self):
        return pygame.Surface((8,40))     

    def niveles_Q(self):
        images_G = self.grilla_images     
        x = self.s_auto.rect.x            
        y = self.s_auto.rect.y            
        self.super_nivelesQ.fill((0,0,0))
        if x < 2528 and y < 1408:
            y = (y / 32) + 1
            x = (x / 32) + 1
            O = (float(images_G[y][x].Oxigeno) / 100) * 40
            C = (float(images_G[y][x].Carbono) / 100) * 40
            N = (float(images_G[y][x].Nitrogeno) / 100) * 40
            H = (float(images_G[y][x].Hidrogeno) / 100) * 40
            self.superficie.fill((255,255,255))
            self.super_nivelesQ.blit(self.superficie,(2, O+2))
            self.superficie.fill((255,255,0))
            self.super_nivelesQ.blit(self.superficie,(15,C+2))
            self.superficie.fill((255,255,34))
            self.super_nivelesQ.blit(self.superficie,(30,N+2))
            self.superficie.fill((255,255,90))
            self.super_nivelesQ.blit(self.superficie,(44,H+2))

    def batery(self):
        V = self.s_auto.bateria_send
        bater = (V / 100.0) * 26
        self.super_hide2.fill((0,0,0))
        if V >= 0 and V < 50:
            self.super_hide.fill((26,255,0))
        if V >= 50 and V < 85:
            self.super_hide.fill((247,255,0))
        if V >=85 and  V <= 100:
            self.super_hide.fill((255,0,0))
        self.super_hide2.blit(self.super_hide,(5,bater+6))    #6
        self.super_bateria.blit(self.super_hide2,(34,2))#-25
        self.super_bateria.blit(self.image_sonda,(2,4))
        self.super_bateria.blit(self.batery_image,(34,2))

    def update(self,screen):
        self.super_total.blit(self.super_f,(2,2))
        self.super_total.blit(self.super_bateria,(100,2))
        self.super_total.blit(self.super_nivelesQ,(100,44))
        self.super_total.blit(self.super_texto,(100,85))
        return self.super_total


def main():
    screen = pygame.display.set_mode((ANCHO, LARGO))

    mapa = pygame.Surface(Mapa)

    s1 = pygame.Surface(Panel)

    s2 = pygame.Surface(Panel)

    s3 = pygame.Surface(Panel)

    s4 = pygame.Surface(Panel)


    sonda = [eSonda() for i in range(0, 4)]    
    baldosa = [eBaldosa() for i in range(0,13)] 
    load_bal(baldosa)                         
    load_sonda(sonda)
    map = new_mapa(baldosa, Mapa)

    sonda1 = Sondas_Automatas(map,sonda[0])
    sonda2 = Sondas_Automatas(map,sonda[1])
    sonda3 = Sondas_Automatas(map,sonda[2])
    sonda4 = Sondas_Automatas(map,sonda[3])

    panel1 = S_panel(sonda1,map,s1)
    panel2 = S_panel(sonda2,map,s2)
    panel3 = S_panel(sonda3,map,s3)
    panel4 = S_panel(sonda4,map,s4)

    reloj = pygame.time.Clock()

    while True:

        for event in pygame.event.get():
            if event.type == pygame.QUIT:
                sys.exit()

        map.scroll()
        map.update(screen)

        sonda1.mover()
        sonda2.mover()
        sonda3.mover()
        sonda4.mover()
        sonda1.update(screen)
        sonda2.update(screen)
        sonda3.update(screen)
        sonda4.update(screen)
        panel1.mostrar()
        panel2.mostrar()
        panel3.mostrar()
        panel4.mostrar()
        pantalla1 = panel1.update(screen)
        pantalla2 = panel2.update(screen)
        pantalla3 = panel3.update(screen)
        pantalla4 = panel4.update(screen)

        screen.blit(pantalla1, (0, 2))
        screen.blit(pantalla2, (162, 2))
        screen.blit(pantalla3, (324, 2))
        screen.blit(pantalla4, (486, 2))
        #reloj.tick(60)
        pygame.display.flip()

if __name__ == '__main__':
    pygame.init()
    main()

 Ejemplo:  

Link -> https://mega.co.nz/#!eYUSAbwR!lwjlrj0Qv5_jrtxt6QyJpCTEFIifa7IT02BrndtH4nI

Programacion

Gestion de regiones

Autor : René Curín

Competencia : Gestion del conocimiento

Asignatura: Programacion II
Palabras claves: Python, Excel

Descripción de la actividad

Crear un programa que sea capaz de procesar un archivo excel que contiene datos sobre personas damnificadas por algun suceso extremo como son lo terremotos, tsunami, tornados, diluvios, destruccion del sistema solar, contraccion del universo o cualquier otro evento natural que cause graves daños, desde el cual se deben extraer los archivos para poder separarlos por regiones y ciudades.

Enunciado de la actividad:

 La fuerza de la naturaleza ha producido a lo largo de la historia del hombre múltiples situaciones catastróficas, causando cuantiosos daños socio-económicos. En el último tiempo, se han registrado continuamente movimientos telúricos, con intensidades de hasta 8 grados Richter de manera casi semanal, aunque por suerte no han sido de gran duración o se podrían dar situaciones lamentables, como la ocurrida el pasado 1 de Abril, cuando un fuerte movimiento telúrico 8.3 Richter produjo fuertes daños en las provincias de la región de Tarapacá. Debido al fuerte sismo, muchas personas perdieron sus viviendas y vivieron (e incluso viven) en albergues provisionales . Se estima que existían sobre 300 mil damnificados en toda la región, esparcidos de acuerdo a la densidad poblacional de cada una de sus provincias.

 

 Tomando en cuenta esta situación como base, pensaremos que para una situación como esta, se podría elaborar una canasta básica de sobrevivencia, la cual contemplaría los siguientes alimentos: agua (litros), azúcar (kilos), arroz(kilos), té (bolsitas), pan (kilos) y paquetes de pasta. 

 Consideraremos dentro de la situación, un reporte de necesidades de cada damnificado entregado por las autoridades pertinentes en su momento (necesidades.csv), en el cual se considera la siguiente información: nombre;provincia;agua,azúcar,arroz,té,pan,pasta.
Debido a la distancia respecto de las otras regiones del país, se entiende que el alimento debería ser distribuido en cada provincia por medio de camiones y que a pesar de los esfuerzos que puedan realizar las autoridades competentes, no es posible entregar a toda la ciudadanía todo lo necesario a la vez, por tanto, los alimentos son entregados parcialmente de acuerdo al arribo de los camiones a cada zona afectada

Objetivos principales

- Aprender extraer informacion de un archivo excel

- Aprender a procesar la informacion y catalogarla

- Diseñar un programa que sea utilizable para diversos casos

Desarrollo de la actividad:

     Estrategia de Trabajo: Comenzamos por analizar los datos que se van a extraer y en la forma que se van a almacenar dentro del programa, luego diseñamos la forma en que separaremos los diferentes datos para luego poder utilzarlos.

    Modelo de Solución: iniziamos leyendo el archivo y extrayendo los diferentes campos en arreglos, lo primero que extrajimos fueron las ciudades, para poder separar los demas datos, luego las personas segun su ciudad, y finalmente los recursos destinados para cada persona, despues esto nos genero varios areglos, los cuales utilizamos para generar graficos y poder asignarle una equvalencia de recursos a las personas que mas necesitaban, y lo que sobraba se lo dejabamos a las personas con mas recursos, generabamos un archivo por cada ciudad que contenia cada persona respecto a su ciudad y el total de personas, ademas de sus necesidades, y luego generamos un grafico de torta para ver que tantas personas damnificadas hubieron por ciudad. 

Codigo Fuente 

 

# -*- encoding: utf-8 -*-
import os
import numpy as np
from pylab import*
import matplotlib.pyplot as plt

def obtener_provincias(x):
    archi = open(str(x),"r")
    prov = []
    cont = 0
    for k in archi:
        k = k.split(";")
        for i in range(len(prov)):
            if k[1] == prov[i]:
                cont = 1
        if cont == 0:
            prov.append(k[1])
        cont = 0
    archi.close()
    return prov

def ordenar(a):
    nombres = []
    for k in a:
        k = k.split(";")
        nom = k[0]
        nom = nom.split(" ")
        nombre = str(nom[2])+" "+str(nom[3])+" "+str(nom[0])+" "+str(nom[1])
        nombres.append(nombre)
    nombres = sorted(nombres)
    final = []
    for k in nombres:
        k = k.split(" ")
        nombre = str(k[2])+" "+str(k[3])+" "+str(k[0])+" "+str(k[1])
        final.append(nombre)
    return final

def crear(x):
    if (os.path.exists(x) == False):
        os.mkdir(x)

def sub_carpetas(x, provincias):
    crear(x)
    for C in provincias:
        crear(x + "/"+ str(C))

def graf_torta(valores,etiquetas,direccion):
    aficion = valores
    etiquetas = etiquetas
    ax = axes([0, 0, 0.8, 1])
    plt.pie(aficion, labels = etiquetas)
    legend()
    ylabel("Numero Personas")
    xlabel("Provincias")
    grid(True)
    plt.savefig(direccion)
    show()

def graf_bar(valores,etiquetas,direccion):
    name =etiquetas
    values=valores
    pos = arange(len(name)) + .5
    plt.bar(pos, values, align='center', color='#b8ff5c')
    xticks(pos,name,rotation=30,size="small")
    plt.savefig(direccion)
    show()

def productos(alimentos):
    agua = []
    pan = []
    azucar=0
    total = 0
    for f in range(len(alimentos)):
        x = alimentos[f]
        total += x[0]+x[1]+x[2]+x[3]+x[4]+x[5]
        agua.append(x[0])
        pan.append(x[4])
        azucar+=int(x[1])
    return agua,pan,azucar,total

def graficos(direccion,personas,provincias,agua,pan):
    crear(direccion)  #"Tarapaca/Reportes/Graficos"
    graf_torta(personas,provincias,str(direccion)+"/damnificados.png")
    graf_torta(agua,provincias,str(direccion)+"/consumo_agua.png")
    graf_bar(pan,provincias,str(direccion)+"/consumo_pan.png")

def repor_requerimiento(direccion,provincias,personas,alimentos):
    crear(direccion)
    requisitos = open(str(direccion)+"/Requerimientos.csv", "a")
    for i in range(len(provincias)):
        requisitos.write(str(provincias[i]) + ";" + str(personas[i]) + ";")
        for n in range(6):
            requisitos.write(str(alimentos[i][n]) + ",")
        requisitos.write(";\n")
    requisitos.close()

def repor_azucar(direc,azucar,doc):
    archi = open(doc,"r")
    text = open(str(direc) + "/provincia_azucar.csv","a")
    disponible = (azucar / 100) * 20
    for i in archi:
        i = i.split(";")
        ali = i[2].split(",")
        line = str(i[0])+";"+str(ali[1])
        if disponible >=0:
            if int(ali[1]) == 3:
                num = int(ali[1]) - 3
                disponible = disponible - 3
                line = str(i[0])+";"+str(num)
        text.write(line+"\n")
        line = ""
    archi.close()

def repor_beneficiados(direc,doc,total,afectado):
    archi = open(doc,"r")
    text = open(str(direc) + "/beneficiados.csv","a")
    disponible = (total / 100) * 70
    for i in archi:
        i = i.split(";")
        ali = i[2].split(",")
        if i[1] == afectado.upper():
            text.write(str(i[0])+";"+i[1]+";"+str(ali[0])+","+str(ali[1])+","+str(ali[2])+","+str(ali[3])+","+str(ali[4])+","+str(ali[5]))
            while int(ali[0]) > 0 or int(ali[1]) > 0 or int(ali[2]) > 0 or int(ali[3]) > 0 or int(ali[4]) > 0 or int(ali[5]) > 0 and disponible > 0:
                for k in range(6):
                    if disponible > 6:
                        if int(ali[k]) != 0:
                                ali[k] = int(ali[k]) - 1
                                disponible -= 1
                    else:
                        break
            #text.write(str(i[0])+";"+i[1]+";"+str(ali[0])+","+str(ali[1])+","+str(ali[2])+","+str(ali[3])+","+str(ali[4])+","+str(ali[5])+"\n")
    archi.close()
    archi = open(doc,"r")
    true = True
    for i in archi:
        i = i.split(";")
        ali = i[2].split(",")
        cont = 2
        if i[1] != afectado.upper() and true == True:
            if int(ali[0]) >= cont and int(ali[1]) >= cont and int(ali[2]) >= cont and int(ali[3]) >= cont and int(ali[4]) >= cont and int(ali[5]) >= cont:
                text.write(str(i[0])+";"+i[1]+";"+str(ali[0])+","+str(ali[1])+","+str(ali[2])+","+str(ali[3])+","+str(ali[4])+","+str(ali[5]))
                while int(ali[0]) > 0 or int(ali[1]) > 0 or int(ali[2]) > 0 or int(ali[3]) > 0 or int(ali[4]) > 0 or int(ali[5]) > 0:
                    if disponible > 6:
                        for k in range(6):
                            if int(ali[k]) != 0:
                                ali[k] = int(ali[k]) - 1
                                disponible -= 1
                    else:
                        true = False
        if i[1] != afectado.upper():
            text1 = open(str(direc) + "/espera_provincia.csv","a")
            text1.write(str(i[0]) +";"+str(i[1])+";"+str(i[2]))
            text1.close()

def terremoto(documento):
    provincias = obtener_provincias(documento)    # Variable para almacenar las provincias
    personas = [0] * len(provincias)    # Variable para almacenar la cantidad de personas
    alimentos = [[0,0,0,0,0,0],[0,0,0,0,0,0],[0,0,0,0,0,0],[0,0,0,0,0,0],[0,0,0,0,0,0],[0,0,0,0,0,0],[0,0,0,0,0,0]]    # variable para almacenar la cantidad de alimentos
    archi = open(documento, "r")
    sub_carpetas("Tarapaca", provincias)    # Se crean las subcaprteas
    for linea in archi:
        linea = linea.split(";")    # Separo la cadena por ; y su resultado seria ['Nombre','provincia','1,5,9,78,45,7']
        prod = linea[2].split(",")    # La pocision 2 de linea son los alimentos y los separo por una coma
        for i in range(len(provincias)):
            if provincias[i] == linea[1]:    # si provicnias(Mayusculas es igual a provincias de la pocicion 1
                personas[i] += 1     # Sumo 1 a la cantidad de personas segun provincia
                text = open("Tarapaca/" + str(provincias[i])+ "/" +str(provincias[i]) + ".csv", "a")
                text.write(str(linea[0]) + ";\n")
                text.close()
                for ali in range(6):
                    alimentos[i][ali] += int(prod[ali])
    archi.close()

    agua,pan,azucar,total = productos(alimentos)   #Obtengo los alimentos
    repor_requerimiento("Tarapaca/Reportes",provincias,personas,alimentos)
    repor_azucar("Tarapaca/Reportes",azucar,documento)
    repor_beneficiados("Tarapaca/Reportes",documento,total,"Iquique")
    graficos("Tarapaca/Reportes/Graficos",personas,provincias,agua,pan)    # Se generan los graficos

#--------Main---------
terremoto("necesidades.csv")

 Imagen de dmostracion: 

 Descargas:

Archivo Excel -> https://mega.co.nz/#!mZ82jDwK!AnXPLSl4DnJIqyY_os3L0iM-4aOXNjZsFhvZTdiY8X8 

Codigo -> https://mega.co.nz/#!yN0nnDZa!1Uanrwzpam16mxaLQuORh0_sJWXlPRA4rzBl1K2d23c

Integracion de Sistemas

Simulacion en 3D

Autor : René Curín

Competencia : Creatividad e innovación

Asignatura: Programacion para la integracion de sistemas
Palabras claves: Python, VisualPython, Codigo.

Descripción de la actividad

 Crear una interfaz en donde se muevan robots de forma aleatoria por un mapa. Estos robots peuden moverse encualquier angulo de 360°, con 3 velocidades diferentes, ademas cada robots debe contar con un nivel de bateria que se ira descargando a medida que se mueva, y cuando alcanze un tope minimo de bateria este debe volver a la base.

Enunciado de la actividad:

 Programe una interfaz donde se mueven los robos de manera aleatoria por el  mapa.  Los robot comienzan moviéndose en cualquier ángulo (0°-359°) con tres velocidades distintas (1,2,3). Cuando los robots chocan con los bordes del mapa deben rebotar teniendo en cuenta su ángulo de impacto. Cada robot dispone de una Batería, la cual se descarga 0.1% toda vez que el robot se mueve. Los robot inician sus movimientos con la Bateria al 100% de carga. Cuando la carga es igual o menor al 5%, el robot debe retornar a su Base para cargar sus baterías. Luego el proceso se repite.


Objetivos principales
- Aprender a utilizar librerias de manejos de objetos 3D

- Crear una interfaz distinguible

. Crear una forma de movimiento para cada robot

Herramientas utilizadas:

- Python 2.7

- Libreria Visual Python (Vpython).

Desarrollo de la actividad:

     Estrategia de Trabajo:

                    La estrategia de trabajo empleado comenzo por analizar como debia ser la interfaz del programa para que se movieran los robots, luego buscamos la forma de poder mover los robots dentro del mapa sin que estos se salgan de su borde, creamos la manera de generar una bateria que se descargara con los movimientos y por ultimo comenzamos a programar todo lo que teniamos analizado

    Modelo de Solución:

                   La solucion del problema comenzo por analizar todas las posibles situaciones, luego programar nuestra interfaz, seguido, dibujamos e insertamos los robots en nuestra interfaz, para los robots creamos una clase que contendria tanto los movimientos, como los limites que debe alcanzar el robot para devolverse y los niveles de bateria disminuyeran.

Codigo Fuente

from visual import *
import math

scene.width = 800
scene.height = 600
f = frame(pos=vector(0,0,0))
base = box(frame = f,pos = vector(0,0,0),    size = (30, 0.5, 40),  material=materials.wood)
orilla_1 =  box(frame = f,pos = vector(15,0.4,0),    size = (0.5, 1.5, 40),  material=materials.wood)
orilla_2 =  box(frame = f,pos = vector(-15,0.4,0),    size = (0.5, 1.5, 40),  material=materials.wood)
orilla_3 = box(frame = f,pos = vector(0,0.4,20),    size = (30.5, 1.5, 0.5),  material=materials.wood)
orilla_4 = box(frame = f,pos = vector(0,0.4,-20),    size = (30.5, 1.5, 0.5),  material=materials.wood)

base_p1 = box(frame = f,pos = vector(12,0.3,17),    size = (3, 0.1, 3),  material=materials.rough)
base_p2 = box(frame = f,pos = vector(-12,0.3,-17),    size = (3, 0.1, 3),  material=materials.rough)
base_p3 = box(frame = f,pos = vector(-12,0.3,17),    size = (3, 0.1, 3),  material=materials.rough)
base_p4 = box(frame = f,pos = vector(12,0.3,-17),    size = (3, 0.1, 3),  material=materials.rough)

p1 = cylinder(pos = vector(12, 0,-17), axis = (0, 1, 0), radius = (0.8), color = color.red)
p2 = cylinder(pos = vector(-12, 0,-17), axis = (0, 1, 0), radius = (0.8), color = color.blue)
p3 = cylinder(pos = vector(12, 0,17), axis = (0, 1, 0), radius = (0.8), color = color.yellow)
p4 = cylinder(pos = vector(-12, 0,17), axis = (0, 1, 0), radius = (0.8), color = color.green)


class robot():
    def __init__(self,robot, base):
        self.robot = robot
        self.base = base
        self.angulo = random.randint(0,359)
        self.x = math.sin(self.angulo)
        self.z = math.cos(self.angulo)
        self.velocidad = random.randint(1, 4)
        self.por_x = 1
        self.por_z = 1
        self.bateria = 10


    def mov(self):
        if self.bateria > 5:
            self.robot.x += (self.x * self.velocidad) * self.por_x
            self.robot.z += (self.z * self.velocidad) * self.por_z
            if self.robot.x > 15 and self.por_x == 1:                   #>15 1 -1
                self.por_x = -1
            elif self.robot.x > 15 and self.por_x == -1:                  #> 15 -1 1
                self.por_x = 1
            if self.robot.x < -15 and self.por_x == 1:                  #<-15 1 -1
                self.por_x = -1
            elif self.robot.x < -15 and self.por_x == -1:                 #<-15 -1 1
                self.por_x = 1
            if self.robot.z > 20 and self.por_z == -1:
                self.por_z = 1
            elif self.robot.z > 20 and self.por_z == 1:
                self.por_z = -1
            if self.robot.z < -20 and self.por_z == 1:
                self.por_z = -1
            elif self.robot.z < -20 and self.por_z == -1:
                self.por_z = 1
            self.bateria -= 0.1
            #print self.bateria
        else:
            self.llegar_base()

    def llegar_base(self):
        if self.base.x != self.robot.x:
            if self.robot.x < self.base.x:
                self.robot.x += 1
            else:
                self.robot.x -= 1

        if self.base.z != self.robot.z:
            if self.robot.z < self.base.z:
                self.robot.z += 1
            else:
                self.robot.z -= 1
        #print self.robot.x, self.robot.z

        if int(self.base.x) == int(self.robot.x):
            self.robot.x = self.base.x
        if int(self.base.z) == int(self.robot.z):
            self.robot.z = self.base.z

        if int(self.robot.x) == int(self.base.x) and int(self.robot.z) == int(self.base.z):
            self.load_batery()

    def load_batery(self):
        ba = 0
        for i in range(10000):
            if i % 100 == 0:
                ba += 1
            #print i
        self.bateria = ba


cont = 0

r1 = robot(p1, base_p1)
r2 = robot(p2, base_p2)
r3 = robot(p3, base_p3)
r4 = robot(p4, base_p4)
while 1:
    rate(100)
    r1.mov()
    r2.mov()
    r3.mov()
    r4.mov()

Imagen de dmostracion:

 

 De que me sirvió esta actividad:

La actividad sirvio como un puente para lo que es la creacion y modelado de objetos 3D asi como tambien programarlos y darles movimientos creados por uno mismo, ademas de la utilizacion de factores como las matematicas ya que para poder calcular los grados de movimiento y el angulo de rebote con los border tuve que utilzar algunas ecuaciones matematicas para poder resolver el problema sin mayoeres complicaciones.