def get_svg(self, outfile):
svg = Svg()
# next add curves
#for curve_points in self.curves:
#svg.curve(map(lambda cp: self._invert_and_offset(cp[0], cp[1]), curve_points), CURVE_WIDTH, CURVE_COLOUR)
# add stars first
for star_data in self.star_data_list.data:
x, y = self._invert_and_offset(star_data.x, star_data.y)
svg.circle(x, y, self._mag_to_d(star_data.mag), STAR_COLOUR)
# next add labels
for star_data in self.star_data_list.data:
if star_data.label:
x, y = self._invert_and_offset(star_data.x, star_data.y)
d = self._mag_to_d(star_data.mag)
#svg.text(x + LABEL_OFFSET_X + d/2, y + LABEL_OFFSET_Y, star_data.label, FONT_COLOUR, FONT_SIZE)
# title
#center_x = self.star_data_list.max_x/2 + MARGIN_X
#svg.text(center_x, MARGIN_Y/2, self.title, TITLE_COLOUR, TITLE_SIZE, 'middle', 'underline')
# coords
#chart_bottom_y = self.star_data_list.max_y + MARGIN_Y
#svg.text(center_x, chart_bottom_y + MARGIN_Y/2, "Right Ascension: {}-{}".format(self.area.ra_min, self.area.ra_max), COORDS_COLOUR, COORDS_SIZE, 'middle')
#svg.text(center_x, chart_bottom_y + MARGIN_Y/2 + COORDS_SIZE, "Declination: {}-{}".format(self.area.dec_min, self.area.dec_max), COORDS_COLOUR, COORDS_SIZE, 'middle')
return svg.to_list()
def __init__(self, file_path):
Svg.__init__(self)
Writer.__init__(self)
Magic.__init__(self)
self.io_dir = os.path.dirname(
os.path.dirname(os.path.abspath(file_path)))
self.res_dir = os.path.join(self.io_dir, 'res')
self.android = Android()
self.file_path = file_path
self.parse()
def files_to_svg_dict(files):
"""Convert a list of images to a dictionary.
Mapping the image basename to the Svg class instance,
setting the dimensions based on sizes and coordinates (0,0) by default
"""
return {s.split('.')[0]: Svg(file=s, coords=(0, 0)) for s in files}
def render_svg(self, outfile):
svg = Svg()
# add stars first
for star_data in self.star_data_list.data:
x, y = self._invert_and_offset(star_data.x, star_data.y)
svg.circle(x, y, self._mag_to_d(star_data.mag), STAR_COLOUR)
# title
#center_x = self.star_data_list.max_x/2 + MARGIN_X
#svg.text(center_x, MARGIN_Y/2, self.title, TITLE_COLOUR, TITLE_SIZE, 'middle', 'underline')
# coords
#chart_bottom_y = self.star_data_list.max_y + MARGIN_Y
#svg.text(center_x, chart_bottom_y + MARGIN_Y/2, "Right Ascension: {}-{}".format(self.area.ra_min, self.area.ra_max), COORDS_COLOUR, COORDS_SIZE, 'middle')
#svg.text(center_x, chart_bottom_y + MARGIN_Y/2 + COORDS_SIZE, "Declination: {}-{}".format(self.area.dec_min, self.area.dec_max), COORDS_COLOUR, COORDS_SIZE, 'middle')
codecs.open(outfile, 'w', 'utf-8').writelines(svg.to_list())
if highlight_addr is not None:
xsel = highlight_addr & (1<<0)
ysel = highlight_addr >> 1
classMap['Y%d' % ysel] = 'active'
classMap['X%d' % xsel] = 'active'
return classMap
app = dash.Dash("Core Mem")
app.layout = html.Div([
html.H1('Magnetic Core Memory Dashboard'),
html.Div([
html.Div([
Svg(id='diagram', value=svg_data(), classMap=get_class_map())
], className='box diagram-box'),
html.Div([memory_value_table()], id='mem-table-div', className='box mem-table-box'),
html.Fieldset([
html.Legend(['Write to Memory']),
html.Span([
'Addr: ',
dcc.Input(id='addrInput', value='0', type='number', min=0, max=7, placeholder="Write Addr"),
]),
html.Span([
'Value: ',
dcc.Input(id='wrValInput', value='0', type='number', min=0, max=255, placeholder="Value"),
]),
html.Button('Write', id='writeButton'),
], className='box write-box'),
html.Fieldset([
import json
from data_source import DataSource
from data_processor import DataProcessor
from svg import Svg
from svg_wrapper import SvgWrapper
from field_names import *
from config import config
planet_data = DataSource().get()
star_data, maxima = DataProcessor(planet_data, config['star_count'],
config['sort_order']).get_star_data()
svg_wrapper = SvgWrapper(Svg(), maxima)
# Save data used to generate SVG - for debugging purposes
if config['dump_data']:
with open(config['dump_data_file'], 'w') as f:
f.write(json.dumps(star_data, indent=4))
for star in star_data:
svg_wrapper.add_star(star)
out_file = config['out_file']
svg_wrapper.save(out_file)
print('Render complete:', out_file)
import sys, json
from svg import Svg
from svg_wrapper import SvgWrapper
from data_processor import process_data
def get_planet_data(planet_name):
with open('data/moon-data.json') as f:
data = json.load(f)
for planet in data:
if planet['planet'].lower() == planet_name.lower():
return planet
if len(sys.argv) == 2:
planet_name = sys.argv[1]
planet_data = get_planet_data(planet_name)
processed_planet_data = process_data(planet_data)
if planet_data:
svg = Svg()
svg_wrapper = SvgWrapper(svg, processed_planet_data)
svg_wrapper.render()
svg_wrapper.save('{}.svg'.format(planet_name))
else:
print('Unknown planet:', planet_name)
else:
print("Usage: python {} <planet name>".format(sys.argv[0]))
def render_svg(self, outfile):
svg = Svg()
# add stars first
for star_data in self.star_data_list.data:
x, y = self._invert_and_offset(star_data.x, star_data.y)
svg.circle(x, y, self._mag_to_d(star_data.mag), STAR_COLOUR)
# next add labels
for star_data in self.star_data_list.data:
if star_data.label:
x, y = self._invert_and_offset(star_data.x, star_data.y)
d = self._mag_to_d(star_data.mag)
svg.text(x + LABEL_OFFSET_X + d / 2, y + LABEL_OFFSET_Y,
star_data.label, FONT_COLOUR, FONT_SIZE)
# next add curves
for curve_points in self.curves:
svg.curve(
[self._invert_and_offset(cp[0], cp[1]) for cp in curve_points],
CURVE_WIDTH, CURVE_COLOUR)
# title
center_x = self.star_data_list.max_x / 2 + MARGIN_X
svg.text(center_x, MARGIN_Y / 2, self.title, TITLE_COLOUR, TITLE_SIZE,
'middle', 'underline')
# coords
chart_bottom_y = self.star_data_list.max_y + MARGIN_Y
svg.text(
center_x, chart_bottom_y + MARGIN_Y / 2,
"Right Ascension: {}-{}".format(self.area.ra_min,
self.area.ra_max), COORDS_COLOUR,
COORDS_SIZE, 'middle')
svg.text(
center_x, chart_bottom_y + MARGIN_Y / 2 + COORDS_SIZE,
"Declination: {}-{}".format(self.area.dec_min, self.area.dec_max),
COORDS_COLOUR, COORDS_SIZE, 'middle')
codecs.open(outfile, 'w', 'utf-8').writelines(svg.to_list())
from sympy import Point,Line,Circle,intersection,Triangle,N
from svg import Svg
C = Point(0,8)
D = Point(0,2)
xaxis = Line(Point(0,0),Point(1,0))
CircleD = Circle(D,2)
tangentE = CircleD.tangent_lines(C)[0]
E = intersection(tangentE,CircleD)[0]
A = intersection(tangentE, xaxis)[0]
CircleD = Circle(D,2)
svg = Svg()
svg.append(C,"C")
#svg.append(D)
svg.append(CircleD,"CircleD")
svg.append(tangentE,"tangE")
svg.append(E,"E")
svg.append(A,"A")
def find_circle(circle,A,C,D,i):
AD = Line(A,D)
svg.append(AD,"AD",i)
K = intersection(circle, AD)[0]
svg.append(K,"K",i)
tangentK = Line(A,D).perpendicular_line(K)
svg.append(tangentK,"tangK",i)
P1 = intersection(tangentK, Line(A,C))[0]
svg.append(P1,"P1",i)
P2 = intersection(tangentK, xaxis)[0]
svg.append(P2,"P2",i)
lds.merge_with_new_frame(lds2)
draw_landmarks(frame, lds)
cv2.imshow('Vid', frame)
return lds.fingerprint()
app = QtGui.QApplication(sys.argv)
svgWidget = QtSvg.QSvgWidget()
svgWidget.setGeometry(50, 50, 759, 668)
svgWidget.show()
video_capture = cv2.VideoCapture(0)
faces = {}
svg = Svg(sys.argv[1])
for fname in sys.argv[1:]:
svg2 = Svg(fname)
svg.merge(fname, svg2)
svgWidget.load(svg.blend({fname: 1}))
face = capture_landmarks(stop='a')
faces[fname] = face
print(faces)
def softmax(xs):
xs = np.exp(xs - np.max(xs))
xs /= np.sum(xs)
return xs
def __init__(self):
super(MainWindow, self).__init__()
self.setupUi(self)
global sensors, CURRENT_TABLE
#self.conn = rdb.connect(host=connData["host"], port=connData["port"], db=connData["db"], auth_key=connData["auth_key"])
self.conn = rdb.connect(host=connData["host"],
port=connData["port"],
db=connData["db"])
# Set a changefeed for "Dispositivos" with initial state reading
devices = rdb.table("devices").run(self.conn)
pp = pprint.PrettyPrinter(indent=4)
# Init the DB reader thread
self.reader = RDBReader(connData, sensors)
self.reader.signalVal.connect(self.slotFromReader)
self.reader.start()
for device in list(devices):
#if device["id"] == CURRENT:
ide = device["id"]
sensors[ide] = device
#table = "D" + ide.replace("-", "")
#sensors[ide]["table"] = table
# Poner todos como OFF y hacer esto en background
if rdb.table(ide).is_empty().run(self.conn) is False:
datos = rdb.table(ide).max("created_at").run(self.conn)
sensors[ide]["canales"] = list()
for k, v in datos["data"].iteritems():
sensors[ide]["canales"].append({"name": k, "value": v})
sensors[ide]["timer"] = Timer(ide, 1000)
sensors[ide]["timer"].timeout.connect(self.slotCountDown)
#secs = (dt.datetime.now(pytz.utc) - parser.parse(datos["created_at"])).total_seconds()
secs = (dt.datetime.now(pytz.utc) -
datos["created_at"]).total_seconds()
sensors[ide]["updated"] = dt.timedelta(seconds=secs)
sensors[ide]["active"] = True
self.reader.addTable(ide)
# print "Tree -----------------------"
# pp = pprint.PrettyPrinter(indent=4)
# pp.pprint(sensors)
# print "-----------------------"
# create Tree
self.createTree()
self.treeWidget.itemClicked.connect(self.on_itemClicked)
# create UI table
self.createTable(self.tableWidget)
self.tableWidget.cellClicked.connect(self.on_graphClicked)
self.show()
# Start timers
# self.reader.addTable("8c3450b7-9a74-4149-9ed3-a4098f4f88b3", "D8c3450b79a7441499ed3a4098f4f88b3")
[s["timer"].start() for s in sensors.values()]
# Svg rendering
self.svg = Svg(self.tabWidget.widget(1), self.svgLayout)
#self.tabWidget.currentChanged.connect(self.doSvg)
# Flip button
self.flipButton.clicked.connect(self.flipAll)
from svg import Element, Svg
svg = Svg()
bck = Element('rect').attr('fill', 'rgba(10,2,3,0.2)')
bck.css({
'x': '0',
'y': '0',
'width': '100',
'height': '100'
});
svg.add(bck)
g = Element('g')
circle = Element('circle').attr({'cx': '0', 'y': '0', 'r': 10, 'fill': 'transparent', 'stroke': '#000'})
cross = Element('g').add(Element('line').attr({'x1':-2, 'y1': 0, 'x2': 2, 'y2': 0, 'stroke': '#000'})).add(Element('line').attr({'x1':0, 'y1': -2, 'x2': 0, 'y2': 2, 'stroke': '#000'})).transform('translate', [0, -3])
minus = Element('g').add(Element('line').attr({'x1':-2, 'y1': 0, 'x2': 2, 'y2': 0, 'stroke': '#000'})).transform('translate', [0, 4])
g.add(cross).add(minus).add(circle)
g.transform('translate', ['50','50'])
svg.add(g)
svg.save('test.svg')