# A Simple UDP class import socket import msgpack from bluesky.network.common import get_ownip from bluesky import settings settings.set_variable_defaults(discovery_port=11000) IS_SERVER = 0 IS_CLIENT = 1 IS_REQUEST = 2 IS_REPLY = 4 class Discovery(object): """simple UDP ping class""" handle = None # Socket for send/recv port = 0 # UDP port we work on address = '' # Own address broadcast = '' # Broadcast address def __init__(self, own_id, is_client=True): self.address = get_ownip() self.broadcast = '255.255.255.255' self.port = settings.discovery_port self.own_id = own_id self.mask = IS_CLIENT if is_client else IS_SERVER # Create UDP socket self.handle = socket.socket(socket.AF_INET, socket.SOCK_DGRAM, socket.IPPROTO_UDP) # Ask operating system to let us do broadcasts from socket self.handle.setsockopt(socket.SOL_SOCKET, socket.SO_BROADCAST, 1)
from .windsim import WindSim from .conditional import Condition from .trails import Trails from .adsbmodel import ADSB from .asas import ASAS from .pilot import Pilot from .autopilot import Autopilot from .activewpdata import ActiveWaypoint from .turbulence import Turbulence from .trafficgroups import TrafficGroups # Register settings defaults settings.set_variable_defaults(performance_model='openap') if settings.performance_model == 'bada': try: print('Using BADA Performance model') from .performance.bada.perfbada import PerfBADA as Perf except Exception as err:# ImportError as err: print(err) print('Falling back to Open Aircraft Performance (OpenAP) model') settings.performance_model = "openap" from .performance.openap import OpenAP as Perf elif settings.performance_model == 'openap': print('Using Open Aircraft Performance (OpenAP) model') from .performance.openap import OpenAP as Perf else: print('Using BlueSky legacy performance model')
""" This module provides PerfBase, the base class for aircraft performance implementations. """ import numpy as np from bluesky import settings from bluesky.core import Entity, timed_function from bluesky.stack import command settings.set_variable_defaults(performance_dt=1.0) class PerfBase(Entity, replaceable=True): """Base class for BlueSky aircraft performance implementations.""" def __init__(self): super().__init__() with self.settrafarrays(): # --- fixed parameters --- self.actype = np.array([], dtype=str) # aircraft type self.Sref = np.array([]) # wing reference surface area [m^2] self.engtype = np.array([]) # integer, aircraft.ENG_TF... # --- dynamic parameters --- self.mass = np.array([]) # effective mass [kg] self.phase = np.array([]) self.cd0 = np.array([]) self.k = np.array([]) self.bank = np.array([]) self.thrust = np.array([]) # thrust self.drag = np.array([]) # drag self.fuelflow = np.array([]) # fuel flow
from .conditional import Condition from .trails import Trails from .adsbmodel import ADSB from .asas import ASAS from .pilot import Pilot from .autopilot import Autopilot from .activewpdata import ActiveWaypoint from .turbulence import Turbulence from .trafficgroups import TrafficGroups from bluesky import settings # Register settings defaults settings.set_variable_defaults(performance_model='openap', snapdt=1.0, instdt=1.0, skydt=1.0, asas_pzr=5.0, asas_pzh=1000.0) if settings.performance_model == 'bada': try: print('Using BADA Performance model') from .performance.bada.perfbada import PerfBADA as Perf except Exception as err: # ImportError as err: print(err) print('Falling back to Open Aircraft Performance (OpenAP) model') settings.performance_model = "openap" from .performance.openap import OpenAP as Perf elif settings.performance_model == 'openap': print('Using Open Aircraft Performance (OpenAP) model') from .performance.openap import OpenAP as Perf
""" Airborne Separation Assurance System. Implements CD&R functionality together with separate conflict detection and conflict resolution modules.""" import numpy as np import bluesky as bs from bluesky import settings from bluesky.tools.simtime import timed_function from bluesky.tools.aero import ft, nm from bluesky.tools.trafficarrays import TrafficArrays, RegisterElementParameters # Register settings defaults settings.set_variable_defaults(prefer_compiled=False, asas_dt=1.0, asas_dtlookahead=300.0, asas_mar=1.2, asas_pzr=5.0, asas_pzh=1000.0, asas_vmin=200.0, asas_vmax=500.0) # Import default CD methods StateBasedCD = False if settings.prefer_compiled: try: from . import casas as StateBasedCD print('StateBasedCD: using compiled version.') except ImportError: print( 'StateBasedCD: using default Python version, no compiled version for this platform.' ) if not StateBasedCD:
from PyQt5 import uic except ImportError: from PyQt4.QtCore import Qt, pyqtSlot, QSize from PyQt4.QtGui import QPixmap, QMainWindow, QIcon, QSplashScreen, \ QItemSelectionModel, QTreeWidgetItem, QPushButton from PyQt4 import uic # Local imports from bluesky.sim.qtgl import StackTextEvent, PanZoomEvent, MainManager as manager from bluesky import settings is_osx = platform.system() == 'Darwin' # Register settings defaults settings.set_variable_defaults(data_path='data', stack_text_color=(0, 255, 0), stack_background_color=(102, 102, 102)) fg = settings.stack_text_color bg = settings.stack_background_color class Splash(QSplashScreen): """ Splash screen: BlueSky logo during start-up""" def __init__(self): super(Splash, self).__init__( QPixmap(settings.data_path + '/graphics/splash.gif'), Qt.WindowStaysOnTopHint) class MainWindow(QMainWindow):
""" BlueSky aircraft performance calculations.""" import os from xml.etree import ElementTree from math import * import numpy as np import bluesky as bs from bluesky.tools.aero import ft, g0, a0, T0, rho0, gamma1, gamma2, beta, R, \ kts, lbs, inch, sqft, fpm, vtas2cas from .performance import esf, phases, calclimits, PHASE from bluesky import settings # Register settings defaults settings.set_variable_defaults(perf_path='data/coefficients', verbose=False) class CoeffBS: """ Coefficient class definition : get aircraft-specific coefficients from database Created by : Isabel Metz References: - D.P. Raymer. Aircraft Design: A Conceptual Approach. AIAA Education Series. American Institute of Aeronautics and Astronautics, Inc., Reston, U.S, fifth edition, 2012. - R. Babikian. The Historical Fuel Efficiency Characteristics of Regional Aircraft from Technological, Operational, and Cost Perspectives. Master's Thesis, Massachusetts Institute of Technology, Boston, U.S. """ def __init__(self):
import numpy as np import OpenGL.GL as gl from ctypes import c_float, c_int, Structure # Local imports import bluesky as bs from bluesky import settings from bluesky.tools.aero import ft, nm, kts from bluesky.sim.qtgl import PanZoomEvent, PanZoomEventType, MainManager as manager from bluesky.navdb import load_aptsurface, load_coastlines from .glhelpers import BlueSkyProgram, RenderObject, Font, UniformBuffer, \ update_buffer, create_empty_buffer # Register settings defaults settings.set_variable_defaults(gfx_path='data/graphics', text_size=13, apt_size=10, wpt_size=10, ac_size=16) # Static defines MAX_NAIRCRAFT = 10000 MAX_NCONFLICTS = 25000 MAX_ROUTE_LENGTH = 100 MAX_POLYPREV_SEGMENTS = 100 MAX_ALLPOLYS_SEGMENTS = 2000 MAX_CUST_WPT = 1000 MAX_TRAILLEN = MAX_NAIRCRAFT * 1000 REARTH_INV = 1.56961231e-7 # Colors red = (255, 0, 0) green = (0, 255, 0)
from .load_navdata_txt import load_navdata_txt from .load_visuals_txt import load_coastline_txt if settings.gui == 'qtgl': from .load_visuals_txt import load_aptsurface_txt else: from .load_visuals_txt import pygame_load_rwythresholds # Cache versions: increment these to the current date if the source data is updated # or other reasons why the cache needs to be updated coast_version = 'v20170101' navdb_version = 'v20170101' aptsurf_version = 'v20170101' ## Default settings settings.set_variable_defaults(navdata_path='data/navdata', cache_path='data/cache') sourcedir = settings.navdata_path cachedir = settings.cache_path class CacheFile(): def __init__(self, fname, version_ref): print('cachefile constructor') self.fname = fname self.version_ref = version_ref self.file = None def check_cache(self): if not path.isfile(self.fname): raise Exception('Cachefile not found: ' + self.fname)
""" BlueSky aircraft performance calculations using BADA 3.xx.""" import numpy as np import bluesky as bs from bluesky.tools.aero import kts, ft, g0, a0, T0, gamma1, gamma2, beta, R from bluesky.tools.trafficarrays import TrafficArrays, RegisterElementParameters from .performance import esf, phases, calclimits, PHASE from bluesky import settings # Register settings defaults settings.set_variable_defaults(perf_path_bada='data/coefficients/BADA', verbose=False) from . import bada_coeff if not bada_coeff.init(settings.perf_path_bada): raise ImportError('BADA performance model: Error loading BADA files from ' + settings.perf_path_bada + '!') else: print('Using BADA performance model.') class PerfBADA(TrafficArrays): """ Aircraft performance implementation based on BADA. Methods: reset() : clear current database create(actype) : initialize new aircraft with performance parameters delete(idx) : remove performance parameters from deleted aircraft perf() : calculate aircraft performance limits() : calculate flight envelope Created by : Isabel Metz Note: This class is based on
''' BlueSky colour palette loader. ''' from os import path from bluesky import settings settings.set_variable_defaults(colour_palette='bluesky-default', gfx_path='data/graphics') def init(): # Load the palette file selected in settings pfile = path.join(settings.gfx_path, 'palettes', settings.colour_palette) if path.isfile(pfile): print('Loading palette ' + settings.colour_palette) exec(compile(open(pfile).read(), pfile, 'exec'), globals()) return True else: print('Palette file not found ' + pfile) return False def set_default_colours(**kwargs): ''' Register a default value for a colour. Use this functionality in the source file where you intend to use those colours so that defaults are always available. Example: from bluesky.ui import palette palette.set_default_colours(mycolor1=(255, 0, 0), mycolor2=(0, 0, 0)) This will make settings.mycolor1 and settings.mycolor2 available, with the provided default values.''' for key, value in kwargs.items(): if key not in globals(): globals()[key] = value
import OpenGL.GL as gl from ctypes import c_float, c_int, Structure # Local imports import bluesky as bs from bluesky import settings from bluesky.ui import palette from bluesky.tools.aero import ft, nm, kts from bluesky.sim.qtgl import PanZoomEvent, PanZoomEventType, MainManager as manager from bluesky.navdb import load_aptsurface, load_coastlines from .glhelpers import BlueSkyProgram, RenderObject, Font, UniformBuffer, \ update_buffer, create_empty_buffer # Register settings defaults settings.set_variable_defaults( gfx_path='data/graphics', text_size=13, apt_size=10, wpt_size=10, ac_size=16) palette.set_default_colours( aircraft=(0,255,0), aptlabel=(220, 250, 255), aptsymbol=(148, 178, 235), background=(0,0,0), coastlines=(85, 85, 115), conflict=(255, 160, 0), pavement=(160, 160, 160), polys=(0,0,255), previewpoly=(0, 204, 255), route=(255, 0, 255), runways=(100, 100, 100), taxiways=(100, 100, 100),
""" BlueSky ADS-B datafeed plugin. Reads the feed from a Mode-S Beast server, and visualizes traffic in BlueSky.""" import time from bluesky import stack, settings, traf from bluesky.tools.network import TcpSocket from bluesky.tools import aero import adsb_decoder as decoder ## Default settings # Mode-S / ADS-B server hostname/ip, and server port settings.set_variable_defaults(modeS_host='', modeS_port=0) # Global data reader = None ### Initialization function of the adsbfeed plugin. def init_plugin(): # Initialize Modesbeast reader global reader reader = Modesbeast() # Configuration parameters config = { 'plugin_name': 'DATAFEED', 'plugin_type': 'sim', 'update_interval': 0.0, 'preupdate': reader.update } stackfunctions = { "DATAFEED": [
''' Main stack functions. ''' import math import os import subprocess import bluesky as bs from bluesky.stack.cmdparser import Command, command, commandgroup from bluesky.stack.basecmds import initbasecmds from bluesky.stack import recorder from bluesky.stack import argparser from bluesky import settings # Register settings defaults settings.set_variable_defaults(start_location="EHAM", scenario_path="scenario") # List of TMX commands not yet implemented in BlueSky tmxlist = ("BGPASAS", "DFFLEVEL", "FFLEVEL", "FILTCONF", "FILTTRED", "FILTTAMB", "GRAB", "HDGREF", "MOVIE", "NAVDB", "PREDASAS", "RENAME", "RETYPE", "SWNLRPASAS", "TRAFRECDT", "TRAFLOGDT", "TREACT", "WINDGRID") # Stack data cmdstack = [] # The actual stack: Current commands to be processed # Scenario details scenname = "" # Currently used scenario name (for reading) scentime = [] # Times of the commands from the read scenario file scencmd = [] # Commands from the scenario file sender_rte = None # bs net route to sender def init(startup_scnfile):
Modification : By : Date : ------------------------------------------------------------------ """ import os from ctypes import c_void_p, pointer, sizeof from PyQt5.QtGui import QImage import OpenGL.GL as gl import numpy as np from bluesky import settings msg1282 = False # GL error 1282 when quitting should only be reported once # Register settings defaults settings.set_variable_defaults(gfx_path='data/graphics') def load_texture(fname): img = QImage(fname) ptr = c_void_p(int(img.constBits())) tex_id = gl.glGenTextures(1) gl.glBindTexture(gl.GL_TEXTURE_2D, tex_id) gl.glTexImage2D(gl.GL_TEXTURE_2D, 0, gl.GL_RGBA8, img.width(), img.height(), 0, gl.GL_BGRA, gl.GL_UNSIGNED_BYTE, ptr) gl.glGenerateMipmap(gl.GL_TEXTURE_2D) gl.glTexParameteri(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_MIN_FILTER, gl.GL_LINEAR_MIPMAP_LINEAR) gl.glTexParameteri(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_MAG_FILTER, gl.GL_LINEAR) return tex_id def create_empty_buffer(size, target=gl.GL_ARRAY_BUFFER, usage=gl.GL_STATIC_DRAW):
""" BlueSky aircraft performance calculations.""" import os from math import * import numpy as np import bluesky as bs from bluesky.tools.aero import ft, g0, a0, T0, rho0, gamma1, gamma2, beta, R, \ kts, lbs, inch, sqft, fpm, vtas2cas from bluesky.tools.trafficarrays import TrafficArrays, RegisterElementParameters from bluesky.traffic.performance.legacy.performance import esf, phases, calclimits, PHASE from bluesky import settings from bluesky.traffic.performance.legacy.coeff_bs import CoeffBS # Register settings defaults settings.set_variable_defaults(perf_path='data/performance/BS', verbose=False) coeffBS = CoeffBS() #tijdelijk om import error in traffic.py op te lossen def test(): a = 1 print('dit is een test') #tijdelijk voor oplossen import error in traffic .py class PerfBS(TrafficArrays): def __init__(self): super(PerfBS, self).__init__()
import os from math import * import numpy as np import bluesky as bs from bluesky.tools.simtime import timed_function from bluesky.tools.aero import ft, g0, a0, T0, rho0, gamma1, gamma2, beta, R, \ kts, lbs, inch, sqft, fpm, vtas2cas from bluesky.tools.trafficarrays import TrafficArrays, RegisterElementParameters from bluesky.traffic.performance.legacy.performance import esf, phases, calclimits, PHASE from bluesky import settings from bluesky.traffic.performance.legacy.coeff_bs import CoeffBS # Register settings defaults settings.set_variable_defaults(perf_path='data/performance/BS', performance_dt=1.0, verbose=False) coeffBS = CoeffBS() class PerfBS(TrafficArrays): def __init__(self): super(PerfBS,self).__init__() self.warned = False # Flag: Did we warn for default perf parameters yet? self.warned2 = False # Flag: Use of piston engine aircraft? # prepare for coefficient readin coeffBS.coeff() with RegisterElementParameters(self): # index of aircraft types in library self.coeffidxlist = np.array([])
""" Implementation of BlueSky's plugin system. """ import ast from os import path import sys from glob import glob import imp import bluesky as bs from bluesky import settings # Register settings defaults settings.set_variable_defaults(plugin_path='plugins', enabled_plugins=['datafeed']) # Dict of descriptions of plugins found for this instance of bluesky plugin_descriptions = dict() # Dict of loaded plugins for this instance of bluesky active_plugins = dict() class Plugin(object): def __init__(self, fname): fname = path.normpath(path.splitext(fname)[0].replace('\\', '/')) self.module_path, self.module_name = path.split(fname) self.module_imp = fname.replace('/', '.') self.plugin_doc = '' self.plugin_name = '' self.plugin_type = '' self.plugin_stack = [] def check_plugin(fname):
import time # Local imports import bluesky as bs from bluesky import settings, stack from bluesky.tools import datalog, areafilter, plugin from bluesky.tools.misc import txt2tim, tim2txt from bluesky.network import Node # Minimum sleep interval MINSLEEP = 1e-3 onedayinsec = 24 * 3600 # [s] time of one day in seconds for clock time # Register settings defaults settings.set_variable_defaults(simdt=0.05) class Simulation(Node): ''' The simulation object. ''' def __init__(self): super(Simulation, self).__init__() self.state = bs.INIT self.prevstate = None # Set starting system time [seconds] self.syst = -1.0 # Benchmark time and timespan [seconds] self.bencht = 0.0 self.benchdt = -1.0
""" BlueSky aircraft performance calculations.""" import os from xml.etree import ElementTree from math import * import numpy as np import bluesky as bs from bluesky.tools.aero import ft, g0, a0, T0, rho0, gamma1, gamma2, beta, R, \ kts, lbs, inch, sqft, fpm, vtas2cas from .performance import esf, phases, calclimits, PHASE from bluesky import settings # Register settings defaults settings.set_variable_defaults(perf_path='data/performance', verbose=False) class CoeffBS: """ Coefficient class definition : get aircraft-specific coefficients from database Created by : Isabel Metz References: - D.P. Raymer. Aircraft Design: A Conceptual Approach. AIAA Education Series. American Institute of Aeronautics and Astronautics, Inc., Reston, U.S, fifth edition, 2012. - R. Babikian. The Historical Fuel Efficiency Characteristics of Regional Aircraft from Technological, Operational, and Cost Perspectives. Master's Thesis, Massachusetts Institute of Technology, Boston, U.S. """ def __init__(self):
''' OpenAP performance library. ''' import os import json import numpy as np import pandas as pd from bluesky import settings settings.set_variable_defaults(perf_path_openap="data/performance/OpenAP") LIFT_FIXWING = 1 # fixwing aircraft LIFT_ROTOR = 2 # rotor aircraft ENG_TYPE_TF = 1 # turbofan, fixwing ENG_TYPE_TP = 2 # turboprop, fixwing ENG_TYPE_TS = 3 # turboshlft, rotor synonyms_db = settings.perf_path_openap + "/synonym.dat" fixwing_aircraft_db = settings.perf_path_openap + "/fixwing/aircraft.json" fixwing_engine_db = settings.perf_path_openap + "/fixwing/engines.csv" fixwing_envelops_dir = settings.perf_path_openap + "/fixwing/wrap/" fixwing_dragpolar_db = settings.perf_path_openap + "/fixwing/dragpolar.csv" rotor_aircraft_db = settings.perf_path_openap + "/rotor/aircraft.json" class Coefficient(): def __init__(self): self.acs_fixwing = self.__load_all_fixwing_flavor() self.engines_fixwing = pd.read_csv(fixwing_engine_db, encoding='utf-8') self.limits_fixwing = self.__load_all_fixwing_envelop() self.acs_rotor = self.__load_all_rotor_flavor()
try: from PyQt5.QtCore import QObject, QEvent, QTimer, pyqtSignal, \ QCoreApplication as qapp except ImportError: from PyQt4.QtCore import QObject, QEvent, QTimer, pyqtSignal, \ QCoreApplication as qapp # Local imports from bluesky import settings, MSG_OK from .simevents import SimStateEventType, SimQuitEventType, BatchEventType, \ BatchEvent, StackTextEvent, StackTextEventType, SimQuitEvent, SetNodeIdType, \ SetActiveNodeType, AddNodeType Listener.fileno = lambda self: self._listener._socket.fileno() # Register settings defaults settings.set_variable_defaults(max_nnodes=cpu_count()) def split_scenarios(scentime, scencmd): start = 0 for i in range(1, len(scencmd) + 1): if i == len(scencmd) or scencmd[i][:4] == 'SCEN': scenname = scencmd[start].split()[1].strip() yield (scenname, scentime[start:i], scencmd[start:i]) start = i class MainManager(QObject): instance = None # Signals nodes_changed = pyqtSignal(str, tuple, int) activenode_changed = pyqtSignal(tuple, int)
""" BlueSky aircraft performance calculations.""" import os from xml.etree import ElementTree from math import * import numpy as np import bluesky as bs from bluesky.tools.aero import ft, g0, a0, T0, rho0, gamma1, gamma2, beta, R, \ kts, lbs, inch, sqft, fpm, vtas2cas from .performance import esf, phases, calclimits, PHASE from bluesky import settings # Register settings defaults settings.set_variable_defaults(perf_path='data/coefficients', verbose=False) class CoeffBS: """ Coefficient class definition : get aircraft-specific coefficients from database Created by : Isabel Metz References: - D.P. Raymer. Aircraft Design: A Conceptual Approach. AIAA Education Series. American Institute of Aeronautics and Astronautics, Inc., Reston, U.S, fifth edition, 2012. - R. Babikian. The Historical Fuel Efficiency Characteristics of Regional Aircraft from Technological, Operational, and Cost Perspectives. Master's Thesis, Massachusetts Institute of Technology, Boston, U.S. """ def __init__(self):
''' OpenAP performance library. ''' import os import json import numpy as np import pandas as pd from bluesky import settings settings.set_variable_defaults(perf_path_openap="data/performance/OpenAP") LIFT_FIXWING = 1 # fixwing aircraft LIFT_ROTOR = 2 # rotor aircraft ENG_TYPE_TF = 1 # turbofan, fixwing ENG_TYPE_TP = 2 # turboprop, fixwing ENG_TYPE_TS = 3 # turboshlft, rotor fixwing_aircraft_db = settings.perf_path_openap + "/fixwing/aircraft.json" fixwing_engine_db = settings.perf_path_openap + "/fixwing/engines.csv" fixwing_envelops_dir = settings.perf_path_openap + "/fixwing/wrap/" rotor_aircraft_db = settings.perf_path_openap + "/rotor/aircraft.json" class Coefficient(): def __init__(self): self.acs_fixwing = self.__load_all_fixwing_flavor() self.engines_fixwing = pd.read_csv(fixwing_engine_db, encoding='utf-8') self.limits_fixwing = self.__load_all_fixwing_envelop() self.acs_rotor = self.__load_all_rotor_flavor() self.limits_rotor = self.__load_all_rotor_envelop()
from bluesky import settings from bluesky.ui import palette from bluesky.ui.radarclick import radarclick from bluesky.ui.qtgl import console from bluesky.ui.qtgl.customevents import ACDataEvent, RouteDataEvent from bluesky.tools.aero import ft, nm, kts from bluesky.tools import geo from bluesky.navdatabase import load_aptsurface, load_coastlines from .glhelpers import BlueSkyProgram, RenderObject, Font, UniformBuffer, \ update_buffer, create_empty_buffer # Register settings defaults settings.set_variable_defaults( gfx_path='data/graphics', text_size=13, apt_size=10, wpt_size=10, ac_size=16, asas_vmin=200.0, asas_vmax=500.0) palette.set_default_colours( aircraft=(0,255,0), aptlabel=(220, 250, 255), aptsymbol=(148, 178, 235), background=(0,0,0), coastlines=(85, 85, 115), conflict=(255, 160, 0), pavement=(160, 160, 160), polys=(0,0,255), previewpoly=(0, 204, 255), route=(255, 0, 255), runways=(100, 100, 100),
try: from collections.abc import Collection, MutableMapping except ImportError: # In python <3.3 collections.abc doesn't exist from collections import Collection, MutableMapping from PyQt5.QtGui import QImage, QOpenGLTexture, QOpenGLBuffer import OpenGL.GL as gl import numpy as np from bluesky import settings from bluesky.ui.qtgl.dds import DDSTexture msg1282 = False # GL error 1282 when quitting should only be reported once # Register settings defaults settings.set_variable_defaults(gfx_path='data/graphics') class Texture(QOpenGLTexture): def __init__(self, fname=None): super().__init__(QOpenGLTexture.Target2D) if fname: self.load(fname) def load(self, fname): if fname[-3:].lower() == 'dds': tex = DDSTexture(fname) self.setFormat(QOpenGLTexture.RGB_DXT1) self.setSize(tex.width, tex.height) self.setWrapMode(QOpenGLTexture.Repeat) self.allocateStorage()
import time # Local imports import bluesky as bs from bluesky import settings, stack # from bluesky.traffic import Metric from bluesky.tools import datalog, areafilter, plugin from bluesky.tools.misc import txt2tim, tim2txt from . import nodemanager as manager from .simevents import StackTextEventType, BatchEventType, BatchEvent, \ SimStateEvent, SimQuitEventType, StackInitEvent onedayinsec = 24 * 3600 # [s] time of one day in seconds for clock time # Register settings defaults settings.set_variable_defaults(simdt=0.05) class Simulation(QObject): # simulation modes init, op, hold, end = list(range(4)) # ========================================================================= # Functions # ========================================================================= def __init__(self): super(Simulation, self).__init__() self.running = True self.state = Simulation.init self.prevstate = None
""" BlueSky Datalogger """ # ToDo: Add description in comments import os import numbers import itertools from datetime import datetime import numpy as np from bluesky import settings, stack from bluesky.tools import varexplorer as ve import bluesky as bs # Register settings defaults settings.set_variable_defaults(log_path='output') logprecision = '%.8f' # Dict to contain the definitions of periodic loggers periodicloggers = dict() # Dict to contain all loggers (also the periodic loggers) allloggers = dict() def crelog(name, dt=None, header=''): ''' Create a new logger from the stack. ''' allloggers[name] = CSVLogger(name, dt or 0.0, header) if dt: periodicloggers[name] = allloggers[name]
import time, datetime # Local imports import bluesky as bs from bluesky import settings, stack from bluesky.tools import datalog, areafilter, plugin, plotter from bluesky.tools.misc import txt2tim, tim2txt # Minimum sleep interval MINSLEEP = 1e-3 onedayinsec = 24 * 3600 # [s] time of one day in seconds for clock time # Register settings defaults settings.set_variable_defaults(simdt=0.05, simevent_port=10000, simstream_port=10001) def Simulation(detached): """ Return Simulation object either in normal network-attached mode or detached mode. """ if detached: from bluesky.network.detached import Node else: from bluesky.network.node import Node class SimulationClass(Node): ''' The simulation object. ''' def __init__(self):
""" BlueSky aircraft performance calculations using BADA 3.xx.""" import numpy as np import bluesky as bs from bluesky.tools.aero import kts, ft, g0, a0, T0, gamma1, gamma2, beta, R, vtas2cas from bluesky.tools.trafficarrays import TrafficArrays, RegisterElementParameters from bluesky.traffic.performance.legacy.performance import esf, phases, calclimits, PHASE from bluesky import settings # Register settings defaults settings.set_variable_defaults(perf_path_bada='data/performance/BADA', verbose=False) from . import coeff_bada if not coeff_bada.init(settings.perf_path_bada): raise ImportError('BADA performance model: Error loading BADA files from ' + settings.perf_path_bada + '!') else: print('Using BADA performance model.') class PerfBADA(TrafficArrays): """ Aircraft performance implementation based on BADA. Methods: reset() : clear current database create(actype) : initialize new aircraft with performance parameters delete(idx) : remove performance parameters from deleted aircraft perf() : calculate aircraft performance limits() : calculate flight envelope Created by : Isabel Metz Note: This class is based on
''' Loader functions for navigation visualisation data. ''' import pickle from bluesky import settings from bluesky.tools import cachefile from bluesky.ui.loadvisuals_txt import load_coastline_txt, load_aptsurface_txt # Cache versions: increment these to the current date if the source data is updated # or other reasons why the cache needs to be updated coast_version = 'v20170101' navdb_version = 'v20170101' aptsurf_version = 'v20171116' ## Default settings settings.set_variable_defaults(navdata_path='data/navdata') sourcedir = settings.navdata_path def load_coastlines(): ''' Load coastline data for gui. ''' with cachefile.openfile('coastlines.p', coast_version) as cache: try: coastvertices = cache.load() coastindices = cache.load() except (pickle.PickleError, cachefile.CacheError) as e: print(e.args[0]) coastvertices, coastindices = load_coastline_txt() cache.dump(coastvertices) cache.dump(coastindices)
# A Simple UDP class import socket import msgpack from bluesky.network.common import get_ownip from bluesky import settings settings.set_variable_defaults(discovery_port=11000) IS_SERVER = 0 IS_CLIENT = 1 IS_REQUEST = 2 IS_REPLY = 4 class Discovery(object): """simple UDP ping class""" handle = None # Socket for send/recv port = 0 # UDP port we work on address = '' # Own address broadcast = '' # Broadcast address def __init__(self, own_id, is_client=True): self.address = get_ownip() self.broadcast = '255.255.255.255' self.port = settings.discovery_port self.own_id = own_id self.mask = IS_CLIENT if is_client else IS_SERVER # Create UDP socket self.handle = socket.socket(socket.AF_INET, socket.SOCK_DGRAM, socket.IPPROTO_UDP)
from PyQt5 import uic except ImportError: from PyQt4.QtCore import Qt, pyqtSlot, QSize from PyQt4.QtGui import QPixmap, QMainWindow, QIcon, QSplashScreen, \ QItemSelectionModel, QTreeWidgetItem, QPushButton from PyQt4 import uic # Local imports from bluesky.sim.qtgl import StackTextEvent, PanZoomEvent, MainManager as manager from bluesky import settings is_osx = platform.system() == 'Darwin' # Register settings defaults settings.set_variable_defaults(gfx_path='data/graphics', stack_text_color=(0, 255, 0), stack_background_color=(102, 102, 102)) fg = settings.stack_text_color bg = settings.stack_background_color class Splash(QSplashScreen): """ Splash screen: BlueSky logo during start-up""" def __init__(self): super(Splash, self).__init__(QPixmap(os.path.join(settings.gfx_path, 'splash.gif')), Qt.WindowStaysOnTopHint) class MainWindow(QMainWindow): """ Qt window process: from .ui file read UI window-definitionof main window """ def __init__(self, app, radarwidget): super(MainWindow, self).__init__()
import os import sys import pygrib import datetime import requests import numpy as np import bluesky as bs from bluesky import settings, stack from bluesky.core import timed_function from bluesky.traffic.windsim import WindSim settings.set_variable_defaults( windgfs_url= "https://www.ncei.noaa.gov/data/global-forecast-system/access/historical/analysis/" ) # nlayer = 23 datadir = settings.data_path + '/grib/' if not os.path.exists(datadir): os.makedirs(datadir) def init_plugin(): global windgfs windgfs = WindGFS() config = {'plugin_name': 'WINDGFS', 'plugin_type': 'sim'} return config
Xavier Olive, 2018 Joost Ellerbroek, 2018 """ import time import requests import numpy as np from os import path try: import cPickle as pickle except ImportError: import pickle from bluesky import stack, settings, traf, scr from bluesky.tools import RegisterElementParameters, TrafficArrays, cachefile settings.set_variable_defaults(opensky_user=None, opensky_password=None, opensky_ownonly=False) # Globals actypedb_version = 'v20180126' reader = None actypes = dict() def init_plugin(): global reader reader = OpenSkyListener() # Load aircraft type database get_actypedb() config = { 'plugin_name': 'OPENSKY',
import cPickle as pickle except ImportError: import pickle from bluesky import settings from load_navdata_txt import load_navdata_txt from load_visuals_txt import load_coastline_txt if settings.gui == 'qtgl': from load_visuals_txt import load_aptsurface_txt else: from load_visuals_txt import pygame_load_rwythresholds ## Default settings settings.set_variable_defaults(navdata_path='data/navdata', cache_path='data/cache') sourcedir = settings.navdata_path cachedir = settings.cache_path def check_cache(cachefile, *sources): if not path.isfile(cachefile): return False cachetm = path.getmtime(cachefile) for source in sources: if path.isfile(source) and path.getmtime(source) > cachetm: return False return True
""" BlueSky aircraft performance calculations.""" import os import numpy as np from xml.etree import ElementTree from math import * import bluesky as bs from bluesky.tools.aero import ft, g0, a0, T0, rho0, gamma1, gamma2, beta, R, \ kts, lbs, inch, sqft, fpm, vtas2cas from performance import esf, phases, calclimits, PHASE from bluesky import settings # Register settings defaults settings.set_variable_defaults(data_path='data', verbose=False) class CoeffBS: """ Coefficient class definition : get aircraft-specific coefficients from database Created by : Isabel Metz References: - D.P. Raymer. Aircraft Design: A Conceptual Approach. AIAA Education Series. American Institute of Aeronautics and Astronautics, Inc., Reston, U.S, fifth edition, 2012. - R. Babikian. The Historical Fuel Efficiency Characteristics of Regional Aircraft from Technological, Operational, and Cost Perspectives. Master's Thesis, Massachusetts Institute of Technology, Boston, U.S. """ def __init__(self): return
from bluesky import settings from bluesky.ui import palette from bluesky.ui.radarclick import radarclick from bluesky.ui.qtgl import console from bluesky.ui.qtgl.customevents import ACDataEvent, RouteDataEvent from bluesky.tools.aero import ft, nm, kts from bluesky.tools import geo from bluesky.navdatabase import load_aptsurface, load_coastlines from .glhelpers import ShaderSet, ShaderProgram, VertexAttributeObject, Font, \ GLBuffer, Circle, Rectangle, Texture # Register settings defaults settings.set_variable_defaults(gfx_path='data/graphics', text_size=13, apt_size=10, wpt_size=10, ac_size=16, asas_vmin=200.0, asas_vmax=500.0) palette.set_default_colors(aircraft=(0, 255, 0), aptlabel=(220, 250, 255), aptsymbol=(148, 178, 235), background=(0, 0, 0), coastlines=(85, 85, 115), conflict=(255, 160, 0), pavement=(160, 160, 160), polys=(0, 0, 255), previewpoly=(0, 204, 255), route=(255, 0, 255), runways=(100, 100, 100),
""" Airborne Separation Assurance System. Implements CD&R functionality together with separate conflict detection and conflict resolution modules.""" import numpy as np import bluesky as bs from bluesky import settings from bluesky.tools.simtime import timed_function from bluesky.tools.aero import ft, nm from bluesky.tools.trafficarrays import TrafficArrays, RegisterElementParameters # Register settings defaults settings.set_variable_defaults(prefer_compiled=False, asas_dt=1.0, asas_dtlookahead=300.0, asas_mar=1.2, asas_pzr=5.0, asas_pzh=1000.0, asas_vmin=200.0, asas_vmax=500.0) # Import default CD methods StateBasedCD = False if settings.prefer_compiled: try: from . import casas as StateBasedCD print('StateBasedCD: using compiled version.') except ImportError: print('StateBasedCD: using default Python version, no compiled version for this platform.') if not StateBasedCD: print('StateBasedCD: using Python version.') from . import StateBasedCD # Import default CR methods from . import DoNothing from . import Eby
import numpy as np import OpenGL.GL as gl from ctypes import c_float, c_int, Structure # Local imports import bluesky as bs from bluesky import settings from bluesky.tools.aero import ft, nm, kts from bluesky.sim.qtgl import PanZoomEvent, PanZoomEventType, MainManager as manager from bluesky.navdb import load_aptsurface, load_coastlines from .glhelpers import BlueSkyProgram, RenderObject, Font, UniformBuffer, \ update_buffer, create_empty_buffer # Register settings defaults settings.set_variable_defaults(text_size=13, apt_size=10, wpt_size=10, ac_size=16) # Static defines MAX_NAIRCRAFT = 10000 MAX_NCONFLICTS = 25000 MAX_ROUTE_LENGTH = 100 MAX_POLYPREV_SEGMENTS = 100 MAX_ALLPOLYS_SEGMENTS = 2000 MAX_CUST_WPT = 1000 MAX_TRAILLEN = MAX_NAIRCRAFT * 1000 REARTH_INV = 1.56961231e-7 # Colors red = (255, 0, 0)
import datetime import time # Local imports import bluesky as bs from bluesky import settings, stack from bluesky.tools import datalog, areafilter, plugin, plotter # Minimum sleep interval MINSLEEP = 1e-3 onedayinsec = 24 * 3600 # [s] time of one day in seconds for clock time # Register settings defaults settings.set_variable_defaults(simdt=0.05, simevent_port=10000, simstream_port=10001) def Simulation(detached): """ Return Simulation object either in normal network-attached mode or detached mode. """ if detached: from bluesky.network.detached import Node else: from bluesky.network.node import Node class SimulationClass(Node): ''' The simulation object. ''' def __init__(self): super(SimulationClass, self).__init__(settings.simevent_port,
""" Autocomplete filenames in the BlueSky console.""" import glob from bluesky import settings # Register settings defaults settings.set_variable_defaults(scenario_path='scenario') previous_g = '' # Case insensitive file search def iglob(pattern): def either(c): return '[%s%s]' % (c.lower(), c.upper()) if c.isalpha() else c return glob.glob(''.join(map(either, pattern))) def reset(): global previous_g previous_g = '' def complete(cmd): """ Command line IC + filename completion function """ lcmd = cmd.upper().split() newcmd = cmd displaytext = '' if lcmd[0] in ['IC', 'BATCH', 'CALL', 'PCALL']: global previous_g g = settings.scenario_path
Xavier Olive, 2018 Joost Ellerbroek, 2018 """ import time import requests import numpy as np from os import path try: import cPickle as pickle except ImportError: import pickle from bluesky import stack, settings, traf, scr from bluesky.tools import RegisterElementParameters, TrafficArrays, cachefile settings.set_variable_defaults(opensky_user=None, opensky_password=None) # Globals actypedb_version = 'v20180126' reader = None actypes = dict() def init_plugin(): global reader reader = OpenSkyListener() # Load aircraft type database get_actypedb() config = { 'plugin_name': 'OPENSKY',
""" Implementation of BlueSky's plugin system. """ import ast from os import path import sys from glob import glob import imp import bluesky as bs from bluesky import settings from bluesky.tools import varexplorer as ve # Register settings defaults settings.set_variable_defaults(plugin_path='plugins', enabled_plugins=['datafeed']) # Dict of descriptions of plugins found for this instance of bluesky plugin_descriptions = dict() # Dict of loaded plugins for this instance of bluesky active_plugins = dict() class Plugin(object): def __init__(self, fname): fname = path.normpath(path.splitext(fname)[0].replace('\\', '/')) self.module_path, self.module_name = path.split(fname) self.module_imp = fname.replace('/', '.') self.plugin_doc = '' self.plugin_name = '' self.plugin_type = '' self.plugin_stack = [] def check_plugin(fname): plugin = None with open(fname, 'rb') as f:
from bluesky import settings if not settings.node_only: from bluesky.sim.qtgl.mainmanager import MainManager from bluesky.ui.qtgl import Gui from bluesky.tools.network import StackTelnetServer if __name__ == "__main__": print(" ***** BlueSky Open ATM simulator *****") print("Distributed under GNU General Public License v3") # Global gui object for easy access in interactive python shell gui = None # Register settings defaults settings.set_variable_defaults(telnet_port=8888) # Create custom system-wide exception handler. For now it replicates python's # default traceback message. This was added to counter a new PyQt5.5 feature # where unhandled exceptions would result in a qFatal with a very uninformative # message. def exception_handler(exc_type, exc_value, exc_traceback): traceback.print_exception(exc_type, exc_value, exc_traceback) sys.exit() sys.excepthook = exception_handler # ============================================================================= # Start the mainloop (and possible other threads)
''' Load visual data from text files.''' import os from math import cos, radians, degrees, sqrt, atan2, sin, asin from zipfile import ZipFile import numpy as np from bluesky import settings ## Default settings settings.set_variable_defaults(navdata_path='data/navdata') REARTH_INV = 1.56961231e-7 def load_coastline_txt(): # -------------------------COASTLINE DATA---------------------------------- # Init geo (coastline) data and convert pen up/pen down format of # coastlines to numpy arrays with lat/lon coast = [] clat = clon = 0.0 with open(os.path.join(settings.navdata_path, 'coastlines.dat'), 'r') as f: print("Reading coastlines.dat") for line in f: line = line.strip() if not (line == "" or line[0] == '#'): arg = line.split() if len(arg) == 3: lat, lon = float(arg[1]), float(arg[2]) if arg[0] == 'D': coast.append([clat, clon, lat, lon]) clat, clon = lat, lon # Sort the line segments by longitude of the first vertex
from .windsim import WindSim from .conditional import Condition from .trails import Trails from .adsbmodel import ADSB from .asas import ASAS from .pilot import Pilot from .autopilot import Autopilot from .activewpdata import ActiveWaypoint from .turbulence import Turbulence from .trafficgroups import TrafficGroups from bluesky import settings # Register settings defaults settings.set_variable_defaults(performance_model='openap', snapdt=1.0, instdt=1.0, skydt=1.0, asas_pzr=5.0, asas_pzh=1000.0) if settings.performance_model == 'bada': try: print('Using BADA Performance model') from .performance.bada.perfbada import PerfBADA as Perf except Exception as err:# ImportError as err: print(err) print('Falling back to Open Aircraft Performance (OpenAP) model') settings.performance_model = "openap" from .performance.openap import OpenAP as Perf elif settings.performance_model == 'openap': print('Using Open Aircraft Performance (OpenAP) model') from .performance.openap import OpenAP as Perf else: print('Using BlueSky legacy performance model')
""" BlueSky Datalogger """ # ToDo: Add description in comments import os import numbers from datetime import datetime import numpy as np from bluesky import settings, stack import bluesky as bs # Register settings defaults settings.set_variable_defaults(log_path='output') logprecision = '%.8f' # Dict to contain the definitions of periodic loggers periodicloggers = dict() # Dict to contain all loggers (also the periodic loggers) allloggers = dict() def registerLogParameters(name, dataparent): if name not in allloggers: allloggers[name] = CSVLogger(name) allloggers[name].dataparents.append(dataparent) return allloggers[name]
""" BlueSky aircraft performance calculations using BADA 3.xx.""" import numpy as np import bluesky as bs from bluesky.tools.aero import kts, ft, g0, a0, T0, gamma1, gamma2, beta, R from bluesky.tools.dynamicarrays import DynamicArrays, RegisterElementParameters from performance import esf, phases, calclimits, PHASE from bluesky import settings # Register settings defaults settings.set_variable_defaults(perf_path_bada='data/coefficients/BADA', verbose=False) import bada_coeff if not bada_coeff.init(settings.perf_path_bada): raise ImportError( 'BADA performance model: Error loading BADA files from ' + settings.perf_path_bada + '!') else: print 'Using BADA performance model.' class PerfBADA(DynamicArrays): """ Aircraft performance implementation based on BADA. Methods: reset() : clear current database create(actype) : initialize new aircraft with performance parameters delete(idx) : remove performance parameters from deleted aircraft perf() : calculate aircraft performance limits() : calculate flight envelope
AMANEventType, NUMEVENTS from .mainwindow import MainWindow, Splash from .docwindow import DocWindow from .radarwidget import RadarWidget from .nd import ND print('Using Qt ' + QT_VERSION_STR + ' for windows and widgets') # Qt smaller than 5.6.2 needs a different approach to pinch gestures correct_pinch = False if QT_VERSION <= 0x050600: import platform correct_pinch = platform.system() == 'Darwin' # Register settings defaults settings.set_variable_defaults(scenario_path='scenario') class Gui(QApplication): modes = ['Init', 'Operate', 'Hold', 'End'] def __init__(self): super(Gui, self).__init__([]) self.acdata = ACDataEvent() self.routedata = RouteDataEvent() self.radarwidget = None self.mousedragged = False self.mousepos = (0, 0) self.prevmousepos = (0, 0) self.panzoomchanged = False self.simt = 0.0
""" External control plugin for Machine Learning applications. """ # Import the global bluesky objects. Uncomment the ones you need from bluesky import stack, sim, traf, settings, tools #, net #, navdb, traf, sim, scr, tools import numpy as np import collections import time from bluesky.traffic import autopilot from gym import spaces from ray.rllib.utils.policy_client import PolicyClient settings.set_variable_defaults(n_ac=1, training_enabled=True, acspd=250, nr_nodes=4, min_lat = 51 , max_lat = 54, min_lon =2 , max_lon = 8, n_neighbours=2 ) print(settings.n_ac) client_mc = None reward = None idx_mc = None reset_bool = True eid = None obs = None prev_obs = None connected = False first_time = None done = None delete_dict = None done_count = 0 lat_eham = 52.18 lon_eham = 4.45 ### Initialization function of your plugin. Do not change the name of this ### function, as it is the way BlueSky recognises this file as a plugin. # Additional initilisation code
''' Traffic OpenGL visualisation. ''' import numpy as np from bluesky.ui.qtgl import glhelpers as glh import bluesky as bs from bluesky.tools import geo from bluesky import settings from bluesky.ui import palette from bluesky.tools.aero import ft, nm, kts # Register settings defaults settings.set_variable_defaults( text_size=13, ac_size=16, asas_vmin=200.0, asas_vmax=500.0) palette.set_default_colours( aircraft=(0, 255, 0), conflict=(255, 160, 0), route=(255, 0, 255), trails=(0, 255, 255)) # Static defines MAX_NAIRCRAFT = 10000 MAX_NCONFLICTS = 25000 MAX_ROUTE_LENGTH = 500 ROUTE_SIZE = 500 TRAILS_SIZE = 1000000 class Traffic(glh.RenderObject, layer=100): ''' Traffic OpenGL object. '''
""" BlueSky aircraft performance calculations using BADA 3.xx.""" import numpy as np import bluesky as bs from bluesky.tools.simtime import timed_function from bluesky.tools.aero import kts, ft, g0, vtas2cas from bluesky.tools.trafficarrays import TrafficArrays, RegisterElementParameters from bluesky.traffic.performance.legacy.performance import esf, phases, calclimits, PHASE from bluesky import settings from . import coeff_bada # Register settings defaults settings.set_variable_defaults(perf_path_bada='data/performance/BADA', performance_dt=1.0, verbose=False) if not coeff_bada.init(settings.perf_path_bada): raise ImportError( 'BADA performance model: Error loading BADA files from ' + settings.perf_path_bada + '!') else: print('Using BADA performance model.') class PerfBADA(TrafficArrays): """ Aircraft performance implementation based on BADA. Methods: reset() : clear current database create(actype) : initialize new aircraft with performance parameters delete(idx) : remove performance parameters from deleted aircraft
from bluesky import settings # Register settings defaults settings.set_variable_defaults(prefer_compiled=False) from .walltime import Timer from .trafficarrays import RegisterElementParameters, TrafficArrays from .signal import Signal if settings.prefer_compiled: try: from . import cgeo as geo print('Using compiled geo functions') except ImportError: from . import geo print('Using Python-based geo functions') else: from . import geo print('Using Python-based geo functions') from .trafficarrays import RegisterElementParameters, TrafficArrays from . import cachefile
try: from PyQt5.QtCore import QObject, QEvent, QTimer, pyqtSignal, \ QCoreApplication as qapp except ImportError: from PyQt4.QtCore import QObject, QEvent, QTimer, pyqtSignal, \ QCoreApplication as qapp # Local imports from bluesky import settings from .simevents import SimStateEventType, SimQuitEventType, BatchEventType, \ BatchEvent, StackTextEvent, SimQuitEvent, SetNodeIdType, \ SetActiveNodeType, AddNodeType Listener.fileno = lambda self: self._listener._socket.fileno() # Register settings defaults settings.set_variable_defaults(max_nnodes=cpu_count()) def split_scenarios(scentime, scencmd): start = 0 for i in range(1, len(scencmd) + 1): if i == len(scencmd) or scencmd[i][:4] == 'SCEN': scenname = scencmd[start].split()[1].strip() yield (scenname, scentime[start:i], scencmd[start:i]) start = i class MainManager(QObject): instance = None # Signals nodes_changed = pyqtSignal(str, tuple, int) activenode_changed = pyqtSignal(tuple, int)