def _update_active_layout_font_properties(self):
family = self.font_families[self.font_select.get_active()]
_titler_data.active_layer.font_family = family.get_name()
_titler_data.active_layer.font_size = self.size_spin.get_value_as_int()
face = FACE_REGULAR
if self.bold_font.get_active() and self.italic_font.get_active():
face = FACE_BOLD_ITALIC
elif self.italic_font.get_active():
face = FACE_ITALIC
elif self.bold_font.get_active():
face = FACE_BOLD
_titler_data.active_layer.font_face = face
align = ALIGN_LEFT
if self.center_align.get_active():
align = ALIGN_CENTER
elif self.right_align.get_active():
align = ALIGN_RIGHT
_titler_data.active_layer.alignment = align
color = self.color_button.get_color()
r, g, b = utils.hex_to_rgb(color.to_string())
new_color = (r / 65535.0, g / 65535.0, b / 65535.0, 1.0)
_titler_data.active_layer.color_rgba = new_color
_titler_data.active_layer.fill_on = self.fill_on.get_active()
# OUTLINE
color = self.out_line_color_button.get_color()
r, g, b = utils.hex_to_rgb(color.to_string())
new_color2 = (r / 65535.0, g / 65535.0, b / 65535.0, 1.0)
_titler_data.active_layer.outline_color_rgba = new_color2
_titler_data.active_layer.outline_on = self.outline_on.get_active()
_titler_data.active_layer.outline_width = self.out_line_size_spin.get_value(
)
# SHADOW
color = self.shadow_color_button.get_color()
r, g, b = utils.hex_to_rgb(color.to_string())
a = self.shadow_opa_spin.get_value() / 100.0
new_color3 = (r / 65535.0, g / 65535.0, b / 65535.0)
_titler_data.active_layer.shadow_color_rgb = new_color3
_titler_data.active_layer.shadow_on = self.shadow_on.get_active()
_titler_data.active_layer.shadow_opacity = self.shadow_opa_spin.get_value(
)
_titler_data.active_layer.shadow_xoff = self.shadow_xoff_spin.get_value(
)
_titler_data.active_layer.shadow_yoff = self.shadow_yoff_spin.get_value(
)
self.view_editor.active_layer.update_rect = True
_titler_data.active_layer.update_pango_layout()
def _update_active_layout_font_properties(self):
family = self.font_families[self.font_select.get_active()]
_titler_data.active_layer.font_family = family.get_name()
_titler_data.active_layer.font_size = self.size_spin.get_value_as_int()
face = FACE_REGULAR
if self.bold_font.get_active() and self.italic_font.get_active():
face = FACE_BOLD_ITALIC
elif self.italic_font.get_active():
face = FACE_ITALIC
elif self.bold_font.get_active():
face = FACE_BOLD
_titler_data.active_layer.font_face = face
align = ALIGN_LEFT
if self.center_align.get_active():
align = ALIGN_CENTER
elif self.right_align.get_active():
align = ALIGN_RIGHT
_titler_data.active_layer.alignment = align
color = self.color_button.get_color()
r, g, b = utils.hex_to_rgb(color.to_string())
new_color = (r/65535.0, g/65535.0, b/65535.0, 1.0)
_titler_data.active_layer.color_rgba = new_color
_titler_data.active_layer.fill_on = self.fill_on.get_active()
# OUTLINE
color = self.out_line_color_button.get_color()
r, g, b = utils.hex_to_rgb(color.to_string())
new_color2 = (r/65535.0, g/65535.0, b/65535.0, 1.0)
_titler_data.active_layer.outline_color_rgba = new_color2
_titler_data.active_layer.outline_on = self.outline_on.get_active()
_titler_data.active_layer.outline_width = self.out_line_size_spin.get_value()
# SHADOW
color = self.shadow_color_button.get_color()
r, g, b = utils.hex_to_rgb(color.to_string())
a = self.shadow_opa_spin.get_value() / 100.0
new_color3 = (r/65535.0, g/65535.0, b/65535.0)
_titler_data.active_layer.shadow_color_rgb = new_color3
_titler_data.active_layer.shadow_on = self.shadow_on.get_active()
_titler_data.active_layer.shadow_opacity = self.shadow_opa_spin.get_value()
_titler_data.active_layer.shadow_xoff = self.shadow_xoff_spin.get_value()
_titler_data.active_layer.shadow_yoff = self.shadow_yoff_spin.get_value()
self.view_editor.active_layer.update_rect = True
_titler_data.active_layer.update_pango_layout()
def drawRects(self, hex_colors):
assert len(hex_colors) == len(self.locations)
for hex_color, loc in zip(hex_colors, self.locations):
rgbtuple = utils.hex_to_rgb(hex_color)
self.qp.setBrush(QtGui.QColor(*rgbtuple))
self.qp.drawRect(loc[1] * self.stride + 10,
loc[0] * self.stride + 10, self.size, self.size)
def __init__(self, **kwargs):
"""
:param hex: 'RRGGBB'
:param r: 0 - 255
:param g: 0 - 255
:param b: 0 - 255
:param h: 0 - 360
:param s: 0 - 100
:param v: 0 - 100
"""
if 'hex' in kwargs:
hex_code = kwargs.get('hex')
self._color = hex_to_rgb(hex_code)
elif 'r' in kwargs and 'g' in kwargs and 'b' in kwargs:
r = bracket(kwargs.get('r'))
g = bracket(kwargs.get('g'))
b = bracket(kwargs.get('b'))
self._color = r, g, b
elif 'h' in kwargs and 's' in kwargs and 'v' in kwargs:
h = bracket(kwargs.get('h'), 0, 360)
s = bracket(kwargs.get('s'), 0, 100)
v = bracket(kwargs.get('v'), 0, 100)
r, g, b = hsv_to_rgb(h / 360.0, s / 100.0, v / 100.0)
self._color = (int(r * 255.0 + 0.5), int(g * 255.0 + 0.5),
int(b * 255.0 + 0.5))
else:
self._color = 0, 0, 0
def by_hex(color_name) -> 'html':
# extract RGB
r, g, b = utils.hex_to_rgb(color_name)
#
msg = 'Color: #{}; RGB({}, {}, {}); '.format(color_name, r, g, b)
# make a sorted array
cp_colors = copy.copy(tikkurila_colors.COLORS)
for clr in cp_colors:
clr[4] = abs(clr[0] - r) + abs(clr[1] - g) + abs(clr[2] - b)
# sort
from operator import itemgetter
cp_colors.sort(key=itemgetter(4))
# hsl
h, l, s = colorsys.rgb_to_hls(r, g, b)
msg += 'HLS: {0:.3f}, {1:.3f}, {2:.3f}.'.format(h, l, s)
# result
return render_template(
'color_by_hex.html',
the_title=TITLE,
the_note='',
the_result='',
the_name_color0=msg,
the_color0=utils.rgb_to_hex(r, g, b),
the_color1=utils.rgb_to_hex(cp_colors[0][0], cp_colors[0][1],
cp_colors[0][2]),
the_color2=utils.rgb_to_hex(cp_colors[1][0], cp_colors[1][1],
cp_colors[1][2]),
the_color3=utils.rgb_to_hex(cp_colors[2][0], cp_colors[2][1],
cp_colors[2][2]),
the_name_color1=cp_colors[0][3],
the_name_color2=cp_colors[1][3],
the_name_color3=cp_colors[2][3],
)
def addNewTrace(self):
'''
fill the table with the parameters added in the dialog
'''
row = self.traceTable.rowCount()
self.traceTable.insertRow(row)
# fill the table with each paramter entered
self.traceTable.setItem(row, 0, QTableWidgetItem(str(self.index)))
self.traceTable.setItem(row, 1, QTableWidgetItem(str(self.LayerCombo.currentText())))
self.traceTable.setItem(row, 2, QTableWidgetItem(str(self.expField1.currentText())))
self.traceTable.setItem(row, 3, QTableWidgetItem(str(self.colorButton.color().name())))
self.index += 1
# get layer and the selected fields (signals and update directly in the UI)
# QgsVectorLayer
lay1 = self.expField1.layer()
# name of the field of the QgsVectorLayer
lay1_f = self.expField1.currentText()
# build the lists from the selected fields
f1 = []
# loop to use normal field or selected expression for first layer
if self.expField1.currentField()[1] == False:
for i in lay1.getFeatures():
f1.append(i[lay1_f])
else:
filter1 = self.expField1.currentField()[0]
exp1 = QgsExpression(filter1)
for i in lay1.getFeatures():
f1.append(exp1.evaluate(i, lay1.pendingFields()))
# get the hex code from the button
colorhex = self.colorButton.color().name()
# convert the hex code to a rgb tuple
colorrgb = hex_to_rgb(colorhex)
# create dictionary with all the plot parameters (each time the button is clicked a ner dictionary is added as VALUE to the initial dictionary)
self.plot_param = dict()
self.plot_param["index"] = self.index
self.plot_param["layer"] = self.LayerCombo.currentLayer()
self.plot_param["Field"]= f1
self.plot_param["Color"] = colorrgb
self.plot_param["Name"] = self.expField1.currentText()
# add the dictionary with plot values to the initial dictionary
self.superdict[row] = self.plot_param
def color_selected(self, color_button):
color = color_button.get_color()
value = utils.hex_to_rgb(color.to_string())
raw_r, raw_g, raw_b = value
val_str = "#" + utils.int_to_hex(int((float(raw_r) * 255.0) / 65535.0)) + \
utils.int_to_hex(int((float(raw_g) * 255.0) / 65535.0)) + \
utils.int_to_hex(int((float(raw_b) * 255.0) / 65535.0))
self.write_value(val_str)
def draw(self, screen):
for y, row in enumerate(self.grid.grid.transpose()):
x = 0
for x, v in enumerate(row):
cell = self.grid.cells[v]
color = cell.color
# color = cell.color if not cell.is_walkable else '#ffffff'
screen.fill(hex_to_rgb(color),
(self.x + x * self.size + 1, self.y +
y * self.size + 1, self.size - 1, self.size - 1))
def _update_active_layout(self, fill_layers_data_if_needed=True):
if self.block_updates:
return
global _titler_data
buf = self.text_view.get_buffer()
text = buf.get_text(buf.get_start_iter(),
buf.get_end_iter(),
include_hidden_chars=True)
if text != _titler_data.active_layer.text:
update_layers_list = True
else:
update_layers_list = False
_titler_data.active_layer.text = text
family = self.font_families[self.font_select.get_active()]
_titler_data.active_layer.font_family = family.get_name()
_titler_data.active_layer.font_size = self.size_spin.get_value_as_int()
face = FACE_REGULAR
if self.bold_font.get_active() and self.italic_font.get_active():
face = FACE_BOLD_ITALIC
elif self.italic_font.get_active():
face = FACE_ITALIC
elif self.bold_font.get_active():
face = FACE_BOLD
_titler_data.active_layer.font_face = face
align = ALIGN_LEFT
if self.center_align.get_active():
align = ALIGN_CENTER
elif self.right_align.get_active():
align = ALIGN_RIGHT
_titler_data.active_layer.alignment = align
color = self.color_button.get_color()
r, g, b = utils.hex_to_rgb(color.to_string())
new_color = (r / 65535.0, g / 65535.0, b / 65535.0, 1.0)
_titler_data.active_layer.color_rgba = new_color
self.view_editor.active_layer.update_rect = True
_titler_data.active_layer.update_pango_layout()
# We only wnat to update layer list data model when this called after user typing
if update_layers_list:
self.layer_list.fill_data_model()
self.view_editor.edit_area.queue_draw()
async def role_colour(self, ctx: utils.CustomContext, role: Role,
colour: str):
"""Sets the colour of a given role."""
hex_regex = r"^#([A-Fa-f0-9]{6}|[A-Fa-f0-9]{3})$"
if not re.match(hex_regex, colour):
return await ctx.send(
"The colour must be a properly formed **hex** colour.")
hex_to_rgb = utils.hex_to_rgb(colour[1:])
colour = discord.Colour.from_rgb(hex_to_rgb[0], hex_to_rgb[1],
hex_to_rgb[2])
await role.edit(colour=colour)
await ctx.thumbsup()
def _update_active_layout(self, fill_layers_data_if_needed=True):
if self.block_updates:
return
global _titler_data
buf = self.text_view.get_buffer()
text = buf.get_text(buf.get_start_iter(), buf.get_end_iter(), include_hidden_chars=True)
if text != _titler_data.active_layer.text:
update_layers_list = True
else:
update_layers_list = False
_titler_data.active_layer.text = text
family = self.font_families[self.font_select.get_active()]
_titler_data.active_layer.font_family = family.get_name()
_titler_data.active_layer.font_size = self.size_spin.get_value_as_int()
face = FACE_REGULAR
if self.bold_font.get_active() and self.italic_font.get_active():
face = FACE_BOLD_ITALIC
elif self.italic_font.get_active():
face = FACE_ITALIC
elif self.bold_font.get_active():
face = FACE_BOLD
_titler_data.active_layer.font_face = face
align = ALIGN_LEFT
if self.center_align.get_active():
align = ALIGN_CENTER
elif self.right_align.get_active():
align = ALIGN_RIGHT
_titler_data.active_layer.alignment = align
color = self.color_button.get_color()
r, g, b = utils.hex_to_rgb(color.to_string())
new_color = (r/65535.0, g/65535.0, b/65535.0, 1.0)
_titler_data.active_layer.color_rgba = new_color
self.view_editor.active_layer.update_rect = True
_titler_data.active_layer.update_pango_layout()
# We only wnat to update layer list data model when this called after user typing
if update_layers_list:
self.layer_list.fill_data_model()
self.view_editor.edit_area.queue_draw()
def get(self, query_string):
"""
query_string : string
5 colour input palette as hex format string
no #s, 5 colours of len 6, total len 30, no delimiters
eg 'bbafa557534d383530726b63958b81'
"""
query_palette = [query_string[i:i + 6] for i in range(0, 30, 6)]
rgb_palette = np.array(
[hex_to_rgb(colour) for colour in query_palette])
palette = rgb_to_lab(rgb_palette)
distances = (np.linalg.norm(all_possible_palettes - palette,
axis=3).sum(axis=2).min(axis=1))
palette_distances = pd.Series(dict(zip(image_ids, distances)))
most_similar_ids = (
palette_distances.sort_values()[1:13].index.values.tolist())
return jsonify({
'request': query_palette,
'response': ids_to_urls(most_similar_ids)
})
def get_value_rgba(self):
raw_r, raw_g, raw_b = utils.hex_to_rgb(self.value)
return (float(raw_r)/255.0, float(raw_g)/255.0, float(raw_b)/255.0, 1.0)
def get_value_as_gdk_color(self):
raw_r, raw_g, raw_b = utils.hex_to_rgb(self.value)
return Gdk.Color(red=(float(raw_r)/255.0),
green=(float(raw_g)/255.0),
blue=(float(raw_b)/255.0))
def _color_hex_to_tuple(value, natron_node, natron_property_name, args):
r, g, b = utils.hex_to_rgb(value)
interpreted_value = ".set(" + str(float(r) / 255.0) + ", " + str(
float(g) / 255.0) + ", " + str(float(b) / 255.0) + ", 1.0)"
return _get_modification_target(
natron_node, natron_property_name) + interpreted_value + NEWLINE
class Mundim(App):
colors = DictProperty({
'black': hex_to_rgb('000000'),
'white': hex_to_rgb('FFFFFF'),
'off_white': hex_to_rgb('F3F3F3'),
'blue_1': hex_to_rgb('73B9E8'),
'green_1': hex_to_rgb('73E89A'),
'debug': hex_to_rgb('FF0000')[:3] + [0.1],
})
patients_ammount = NumericProperty(-1)
patients = ListProperty([])
no_prognostic_patients_ammount = NumericProperty(-1)
no_prognostic_patients = ListProperty([])
def load_patients(self, threaded=False, delay=0):
def _load_patients():
patients = load_query("SELECT * FROM patients")
for patient in patients:
patient['size_hint'] = [None, None]
patient['size'] = dp(300), dp(50)
self.patients = patients
self.patients_ammount = len(self.patients)
if delay:
Clock.schedule_once(
(lambda x: self.load_patients(threaded=threaded)), delay
)
return
if threaded:
Thread(target=_load_patients, args=[]).start()
else:
_load_patients()
def on_patients(self, instance, value):
no_prognostic_patients = []
for patient in value:
if patient['biopsy_diagnostic'] == '':
no_prognostic_patients.append(patient)
self.no_prognostic_patients = no_prognostic_patients
self.no_prognostic_patients_ammount = len(self.no_prognostic_patients)
def on_start(self):
from kivy.base import EventLoop
EventLoop.window.bind(on_keyboard=self.hook_keyboard)
self.load_patients(threaded=True, delay=1)
Clock.schedule_interval(lambda x: self.load_patients(threaded=True), 60)
if platform == 'android':
set_statusbar_color('#FFFFFF')
@staticmethod
def check_request_permission():
if platform != "android":
return
from android.permissions import (
Permission, request_permission, check_permission)
permission = Permission.CAMERA
if not check_permission(permission):
request_permission(permission)
def hook_keyboard(self, window, key, *largs):
if key == 27:
self.root.undo()
return True
def build(self):
self.check_request_permission()
self.root = MundimRoot()
self.root.app = self
return self.root
def addNewTrace(self):
'''
fill the table with the parameters added in the dialog
'''
row = self.traceTable.rowCount()
self.traceTable.insertRow(row)
# fill the table with each paramter entered
self.traceTable.setItem(row, 0, QTableWidgetItem(str(self.index)))
self.traceTable.setItem(row, 1, QTableWidgetItem(str(self.LayerCombo.currentText())))
self.traceTable.setItem(row, 2, QTableWidgetItem(str(self.expField1.currentText())))
self.traceTable.setItem(row, 3, QTableWidgetItem(str(self.colorButton.color().name())))
self.traceTable.setItem(row, 4, QTableWidgetItem(str(self.alpha.value())))
self.index += 1
# get layer and the selected fields (signals and update directly in the UI)
# QgsVectorLayer
lay1 = self.expField1.layer()
# name of the field of the QgsVectorLayer
lay1_f = self.expField1.currentText()
# build the lists from the selected fields
f1 = []
# loop to use normal field or selected expression for first layer
if self.expField1.currentField()[1] == False:
for i in lay1.getFeatures():
f1.append(i[lay1_f])
else:
filter1 = self.expField1.currentField()[0]
exp1 = QgsExpression(filter1)
for i in lay1.getFeatures():
f1.append(exp1.evaluate(i, lay1.pendingFields()))
# get the hex code from the button
colorhex = self.colorButton.color().name()
# convert the hex code to a rgb tuple
colorrgb = hex_to_rgb(colorhex)
# value of the slider for the alpha channel
alphavalue = self.alpha.value()
# create dictionary with all the plot parameters (each time the button is clicked a ner dictionary is added as VALUE to the initial dictionary)
self.plot_param = dict()
self.plot_param["index"] = self.index
self.plot_param["layer"] = (self.LayerCombo.currentLayer())
self.plot_param["Field"]= f1
self.plot_param["Color"] = colorrgb
self.plot_param["Transparency"] = alphavalue
self.plot_param["Name"] = self.expField1.currentText()
# add the dictionary with plot values to the initial dictionary
self.superdict[row] = self.plot_param
def get_value_as_gdk_color(self):
raw_r, raw_g, raw_b = utils.hex_to_rgb(self.value)
return Gdk.Color(red=(float(raw_r) / 255.0),
green=(float(raw_g) / 255.0),
blue=(float(raw_b) / 255.0))
def addNewTrace(self):
'''
fill the table with the parameters added in the dialog
'''
row = self.traceTable.rowCount()
self.traceTable.insertRow(row)
# fill the table with each paramter entered
self.traceTable.setItem(row, 0, QTableWidgetItem(str(self.index)))
self.traceTable.setItem(
row, 1, QTableWidgetItem(str(self.LayerCombo.currentText())))
self.traceTable.setItem(
row, 2, QTableWidgetItem(str(self.expField1.currentText())))
self.traceTable.setItem(
row, 3, QTableWidgetItem(str(self.expField2.currentText())))
if self.dataDefined.isActive():
self.traceTable.setItem(
row, 4, QTableWidgetItem(str(self.dataDefined.getField())))
else:
self.traceTable.setItem(row, 4,
QTableWidgetItem(str(self.Size.value())))
self.traceTable.setItem(
row, 5, QTableWidgetItem(str(self.colorButton.color().name())))
self.traceTable.setItem(row, 6,
QTableWidgetItem(str(self.alpha.value())))
self.index += 1
# get layer and the selected fields (signals and update directly in the UI)
# QgsVectorLayer
lay1 = self.expField1.layer()
# name of the field of the QgsVectorLayer
lay1_f = self.expField1.currentText()
# QgsVectorLayer
lay2 = self.expField2.layer()
# name of the field of the QgsVectorLayer
lay2_f = self.expField2.currentText()
# build the lists from the selected fields
f1 = []
f2 = []
# loop to use normal field or selected expression for first layer
if self.expField1.currentField()[1] == False:
for i in lay1.getFeatures():
f1.append(i[lay1_f])
else:
filter1 = self.expField1.currentField()[0]
exp1 = QgsExpression(filter1)
for i in lay1.getFeatures():
f1.append(exp1.evaluate(i, lay1.pendingFields()))
# loop to use normal field or selected expression for second layer
if self.expField2.currentField()[1] == False:
for i in lay2.getFeatures():
f2.append(i[lay2_f])
else:
filter2 = self.expField2.currentField()[0]
exp2 = QgsExpression(filter2)
for i in lay2.getFeatures():
f2.append(exp2.evaluate(i, lay2.pendingFields()))
# get the hex code from the button
colorhex = self.colorButton.color().name()
# convert the hex code to a rgb tuple
colorrgb = hex_to_rgb(colorhex)
# color for the outline line
colorhex2 = self.colorButton2.color().name()
# convert the hex code to a rgb tuple
colorrgb2 = hex_to_rgb(colorhex2)
# value of the slider for the alpha channel
alphavalue = self.alpha.value()
# size settings
if self.dataDefined.isActive() == False:
markSize = self.Size.value()
else:
markSize = []
if self.dataDefined.useExpression() == True:
sizefilter = self.dataDefined.getExpression()
sizeexp = QgsExpression(sizefilter)
for i in self.LayerCombo.currentLayer().getFeatures():
markSize.append(
sizeexp.evaluate(
i,
self.LayerCombo.currentLayer().pendingFields()))
else:
for i in self.LayerCombo.currentLayer().getFeatures():
markSize.append(i[self.dataDefined.getField()])
# create dictionary with all the plot parameters (each time the button is clicked a ner dictionary is added as VALUE to the initial dictionary)
self.plot_param = dict()
self.plot_param["index"] = self.index
self.plot_param["layer"] = (self.LayerCombo.currentLayer())
self.plot_param["R"] = f1
self.plot_param["T"] = f2
self.plot_param["Size"] = markSize
self.plot_param["Color"] = colorrgb
self.plot_param["OutLine_Color"] = colorrgb2
self.plot_param["Transparency"] = alphavalue
self.plot_param["Name"] = self.expField2.currentText()
# add the dictionary with plot values to the initial dictionary
self.superdict[row] = self.plot_param
def __init__(self, x=0, y=0, size=5, color='#000000'):
self.size = size
self.x = x
self.y = y
self.color = hex_to_rgb(color)
def __init__(self, background='#ffffff', size=[1024, 768]):
self.drawers = []
self.size = size
self.background = hex_to_rgb(background)
def fetch_rgb(self):
hex_colors, freq_staleness = self.get_hex_arr()
for i, hex_color in enumerate(hex_colors):
rgbtuple = utils.hex_to_rgb(hex_color)
self.data[3 * i:3 * i + 3] = rgbtuple
def _color_hex_to_tuple(value, natron_node, natron_property_name, args):
r, g, b = utils.hex_to_rgb(value)
interpreted_value = ".set(" + str(float(r)/255.0) + ", " + str(float(g)/255.0) + ", " + str(float(b)/255.0) + ", 1.0)"
return _get_modification_target(natron_node, natron_property_name) + interpreted_value + NEWLINE
def __init__(self, x, y, color='#000000', width=5, size=25):
self.x = x
self.y = y
self.color = hex_to_rgb(color)
self.size = size
self.width = width
def addNewTrace(self):
'''
fill the table with the parameters added in the dialog
'''
row = self.traceTable.rowCount()
self.traceTable.insertRow(row)
# fill the table with each paramter entered
self.traceTable.setItem(row, 0, QTableWidgetItem(str(self.index)))
self.traceTable.setItem(row, 1, QTableWidgetItem(str(self.LayerCombo.currentText())))
self.traceTable.setItem(row, 2, QTableWidgetItem(str(self.expField1.currentText())))
self.traceTable.setItem(row, 3, QTableWidgetItem(str(self.expField2.currentText())))
if self.dataDefined.isActive():
self.traceTable.setItem(row, 4, QTableWidgetItem(str(self.dataDefined.getField())))
else:
self.traceTable.setItem(row, 4, QTableWidgetItem(str(self.Size.value())))
self.traceTable.setItem(row, 5, QTableWidgetItem(str(self.symbolCombo.currentText())))
self.traceTable.setItem(row, 6, QTableWidgetItem(str(self.colorButton.color().name())))
self.traceTable.setItem(row, 7, QTableWidgetItem(str(self.alpha.value())))
self.index += 1
# get layer and the selected fields (signals and update directly in the UI)
# QgsVectorLayer
lay1 = self.expField1.layer()
# name of the field of the QgsVectorLayer
lay1_f = self.expField1.currentText()
# QgsVectorLayer
lay2 = self.expField2.layer()
# name of the field of the QgsVectorLayer
lay2_f = self.expField2.currentText()
# build the lists from the selected fields
f1 = []
f2 = []
# cicle to use normal field or selected expression for first layer
if self.expField1.currentField()[1] == False:
for i in lay1.getFeatures():
f1.append(i[lay1_f])
else:
filter1 = self.expField1.currentField()[0]
exp1 = QgsExpression(filter1)
for i in lay1.getFeatures():
f1.append(exp1.evaluate(i, lay1.pendingFields()))
# cicle to use normal field or selected expression for second layer
if self.expField2.currentField()[1] == False:
for i in lay2.getFeatures():
f2.append(i[lay2_f])
else:
filter2 = self.expField2.currentField()[0]
exp2 = QgsExpression(filter2)
for i in lay2.getFeatures():
f2.append(exp2.evaluate(i, lay2.pendingFields()))
# get the hex code from the button
colorhex = self.colorButton.color().name()
# convert the hex code to a rgb tuple
colorrgb = hex_to_rgb(colorhex)
# color for the outline line
colorhex2 = self.colorButton2.color().name()
# convert the hex code to a rgb tuple
colorrgb2 = hex_to_rgb(colorhex2)
# value of the slider for the alpha channel
alphavalue = self.alpha.value()
# size settings
if self.dataDefined.isActive() == False:
markSize = self.Size.value()
else:
markSize = []
if self.dataDefined.useExpression() == True:
sizefilter = self.dataDefined.getExpression()
sizeexp = QgsExpression(sizefilter)
for i in self.LayerCombo.currentLayer().getFeatures():
markSize.append(sizeexp.evaluate(i, self.LayerCombo.currentLayer().pendingFields()))
else:
for i in self.LayerCombo.currentLayer().getFeatures():
markSize.append(i[self.dataDefined.getField()])
# symbol choice
symbol = self.symbolCombo.currentText()
# create dictionary with all the plot parameters (each time the button is clicked a ner dictionary is added as VALUE to the initial dictionary)
self.plot_param = dict()
self.plot_param["index"] = self.index
self.plot_param["layer"] = (self.LayerCombo.currentLayer())
self.plot_param["X"]= f1
self.plot_param["Y"] = f2
self.plot_param["Size"]= markSize
self.plot_param["Marker"] = symbol
self.plot_param["Color"] = colorrgb
self.plot_param["OutLine_Color"] = colorrgb2
self.plot_param["OutLine_Width"] = self.widthBox.value()
self.plot_param["Transparency"] = alphavalue
self.plot_param["Name"] = self.expField2.currentText()
# add the dictionary with plot values to the initial dictionary
self.superdict[row] = self.plot_param
def card_background(self):
"""Turns hex and opacity to RBGA Tuple"""
return utils.hex_to_rgb(self.card_bg[0]) + (self.card_bg[1], )
def get_value_rgba(self):
raw_r, raw_g, raw_b = utils.hex_to_rgb(self.value)
return (float(raw_r) / 255.0, float(raw_g) / 255.0,
float(raw_b) / 255.0, 1.0)
def draw_experiment_label(experiment_info):
# create group
experiment_label = bpy.data.objects.new("experiment_label", None)
bpy.context.scene.objects.link(experiment_label)
# define some positions and parameters
x = experiment_info["x"] + experiment_info["w"] / 2
y = -0.51
z = -2
z_text_offset = 0.5
width = experiment_info["w"]
depth = 2
extrusion = 1
# add text
bpy.ops.object.text_add()
obj = bpy.context.scene.objects[0]
obj.data.font = font
obj.data.body = experiment_info["experiment"]
obj.data.align_x = "CENTER"
obj.data.align_y = "CENTER"
obj.data.edit_format.use_bold = True
obj.location = Vector((x, y - extrusion - 0.05, z + z_text_offset))
obj.rotation_euler = Vector((np.pi / 2, 0, 0))
obj.data.size = 1.7
obj.parent = experiment_label
color = utils.hex_to_rgb(experiment_info["color"])
# text color
mat = bpy.data.materials.new('Material')
mat.diffuse_color = color
mat.diffuse_intensity = 0.4
obj.data.materials.append(mat)
# draw box
bm = bmesh.new()
face = bm.faces.new([
bm.verts.new([x - width / 2, y, z - depth / 2]),
bm.verts.new([x + width / 2, y, z - depth / 2]),
bm.verts.new([x + width / 2, y, z + depth / 2]),
bm.verts.new([x - width / 2, y, z + depth / 2])
])
# extrude
bmesh.ops.recalc_face_normals(bm, faces=[face])
r = bmesh.ops.extrude_discrete_faces(bm, faces=[face])
f = r['faces'][0]
bmesh.ops.translate(bm, vec=Vector((0, -extrusion, 0)), verts=f.verts)
obj = create_object(bm)
obj.parent = experiment_label
# box color
color = [.9, .9, .9]
mat = bpy.data.materials.new('Material')
mat.diffuse_color = color
mat.diffuse_intensity = 0.7
obj.data.materials.append(mat)
return experiment_label