示例#1
0
    def __init__(self):
        # Inicializamos todo:

        # Variables de la clase
        self.width = 800
        self.height = 800
        self.aspect = self.width / self.height
        self.angulo = 0
        self.window = 0

        self.Sol = model.Modelo()
        self.camara = camara.camara()
        self.material = material.material()
        self.foco = foco.foco()
        self.planeta = planeta.planeta()

        self.focos_configurados = False
        self.mostrar_ejes = False
        self.mostrar_orbitas = True

        # Tamaño de los ejes y del alejamiento de Z.
        self.tamanio = 40
        self.z0 = 0

        # Factor para el tamaño del modelo.
        self.escalaGeneral = 0.001

        # Rotacion de los modelos.
        self.alpha = 0
        self.beta = 0

        # Variables para la gestion del ratón.
        self.xold = 0
        self.yold = 0
        self.zoom = 1.0

        # Vistas del Sistema Planetario.
        # modelo.tipoVista iForma
        self.iDibujo = 3
        self.iFondo = 0
        self.iForma = 6
示例#2
0
        soma += (autocor[i]**2) / (n - i)
    Q = n * (n + 2) * soma
    critical = chisq.ppf(conf, lagmax)
    pval = 1 - chisq.cdf(Q, lagmax)
    print("Região crítica: [{}, +Inf]\n \
          Estatistica calculada: {}\n \
          Valor-p: {}".format(critical, Q, pval))
    return([Q, critical, pval])


if __name__ == '__main__':
    import csv
    import numpy as np
    dat = []
    fit = []
    res = []
    with open('airpass.txt', 'r') as arq:
        x = csv.reader(arq)
        for lin in x:
            dat.append(lin[0])
            fit.append(lin[1])
            res.append(lin[2])
    fit = np.array(fit[1:len(dat)], dtype=np.float)
    res = np.array(res[1:len(dat)], dtype=np.float)
    dat = np.array(dat[1:len(dat)], dtype=np.float)
    np.set_printoptions(suppress=True)
    import modelo
    mod = modelo.Modelo(dat, p=2, d=1, q=1, transformation='log')
    print(mod.phi, mod.the)
    stats = ljungbox(mod)
示例#3
0
import utilities
import modelo
import sys
try:
    clf_filename = sys.argv[1]
except IndexError as error:
    clf_filename = ""

# Help
if (clf_filename == ""):
    print(
        'You must be specify the model path, like: modelo/modeloEntrenado.pkl')

# clf_filename = "modelo/modeloEntrenado2.pkl" #Ubicacion del modelo entrenado

modelClass = modelo.Modelo()

cap = cv2.VideoCapture(1)
frameCount = 0  #contar el numero de frames

frames = utilities.Config.frames()

while True and clf_filename != "":
    ret, frame = cap.read()  #captura frame by frame
    gray = cv2.cvtColor(frame,
                        cv2.COLOR_BGR2GRAY)  #pasar el frame a escala de grises
    ret, thresh_img = cv2.threshold(gray, 91, 255,
                                    cv2.THRESH_BINARY_INV)  #binarizar el frame
    [fil, col] = gray.shape  ##obtener las dimensiones del frame

    ymargin = 150  ##un margen en y para el recuadro de enfoque
示例#4
0
    def __init__(self, data =None):
        #Inicializamos todo:
        self.im = Image.open("stars64.bmp")
        self.d = np.array(self.im).reshape(-1,1)
        self.im.close()

        #Variables de la clase
        self.width=800
        self.height=800
        self.aspect = self.width/self.height
        self.angulo = 0
        self.window=0

        #**Cargamos Materiales**
        self.materiales = data["materiales"]
        self.NUM_MATERIALES = len(self.materiales)
        for i in range (self.NUM_MATERIALES):
            self.materialesCargados.append(material.Material(self.materiales[i]["luzambiente"], self.materiales[i]["luzspecular"], self.materiales[i]["luzdifusa"], self.materiales[i]["brillo"]))
            print("&Material",i,"cargado desde JSON")

        #**Cargar Astros**
        numLunas=0
        self.planetas = data["planetas"]
        self.NUM_ASTROS = len(self.planetas)
            #Aqui cargamos los datos en modelos y los guardamos en una lista llamada astros
        for i in range(self.NUM_ASTROS):
            if(self.planetas[i]["l"]=="n"):
                numLunas=0
                self.astros.append(model.Modelo(self.planetas[i], self.materialesCargados[i]))
                print("&Planeta",i,"cargado desde JSON")
            elif(self.planetas[i]["l"]=="l"):
                numLunas+=1
                self.astros[i-numLunas].addLuna(model.Modelo(self.planetas[i], self.materialesCargados[i]))
                #self.lunas.append(model.Modelo(self.planetas[i], self.materialesCargados[i]))
                print("&Luna",numLunas,"del planeta",self.astros[i-numLunas].nombre,"cargado desde JSON")

        #**Cargar Camaras**
        self.camaras = data["camaras"]
        self.numCamaras = len(self.camaras)
            #Cargamos las camaras de data en objetos Camara_Frustum
        for i in range (self.numCamaras):
            self.camarasCargadas.append(cf.Camera_Frustum(self.camaras[i]["ejex"], self.camaras[i]["ejey"], self.camaras[i]["ejez"], 
            self.camaras[i]["centrox"], self.camaras[i]["centroy"], self.camaras[i]["centroz"],
            self.camaras[i]["upx"], self.camaras[i]["upy"], self.camaras[i]["upz"]))
            print("&Camara",i,"cargada desde JSON")

        #**Cargamos Focos**
        self.focos = data["focos"]
        self.NUM_FOCOS=len(self.focos)
        for i in range (self.NUM_FOCOS):
            self.focosCargados.append(foco.Foco(self.focos[i]["brillo"], self.focos[i]["luzdifusa"], self.focos[i]["luzambiente"], self.focos[i]["luzspecular"], self.focos[i]["posicion"]))
            print("&Foco",i,"cargado desde JSON")

        #Tamaño de los ejes y del alejamiento de Z.
        self.tamanio=0
        self.z0=0

        #Factor para el tamaño del modelo.
        self.escalaGeneral = 0.013
        self.multiplicadorVelocidad = 15

        #Rotacion de los modelos.
        self.alpha=0
        self.beta=0

        #Variables para la gestion del ratón.
        self.xold=0
        self.yold=0
        self.zoom=1.0

        #Vistas del Sistema Planetario.
        #modelo.tipoVista iForma
        self.iDibujo=3
        self.iFondo=0
        self.iForma=6
        self.iCamara=10
示例#5
0
# Importando os pacotes
import modelo as mdl
import pandas as pd
import numpy as np
import socket
import pytz
from MetaTrader5 import *
from datetime import datetime
from sklearn.externals import joblib


rates_frame = pd.DataFrame()
modelo = mdl.Modelo()

# load the model
#model = joblib.load('modelo_rf_indice_easy.pkl')

# Obtem os dados do ultimo candle: time, open, close, high, low, volume
def getRatesFromMT5():
	# Initializing MT5 connection 
	MT5Initialize()
	MT5WaitForTerminal()

	# Lendo dados do mercado
	timezone = pytz.timezone("America/Sao_Paulo")
	data = datetime.now(tz=timezone)
	utc_from = datetime(data.year, data.month, data.day, data.hour, data.minute, tzinfo=timezone)
	#utc_from = datetime(data.year, 4, 30, 17, 50, tzinfo=timezone)
	rates = MT5CopyRatesFrom("WINM19", MT5_TIMEFRAME_M5, utc_from, 1)
	MT5Shutdown()