def test_image_format():
# Test that these format names don't throw an error
Image(format='png')
Image(format='jpeg')
Image(format='url')
class CameraWatcher(Watcher):
def __init__(self, camera, **kwargs):
super().__init__()
self.camera = camera
if "max_width" not in kwargs:
kwargs["max_width"] = "100%"
if "height" not in kwargs:
kwargs["height"] = "auto"
if "width" not in kwargs:
kwargs["width"] = "500px"
self.widget = Image(layout=Layout(**kwargs))
self.widget.add_class("pixelated")
# Update and draw:
self.draw()
def draw(self):
picture = self.camera.get_image()
self.widget.value = image_to_png(picture)
def update(self):
pass
def reset(self):
pass
def anim(func, time_length, interval=0.1, width=400):
img = Image_widget(width=width)
display(img)
start_time = time.time()
for t in np.arange(0, time_length, interval):
frame = Image.fromarray((func(t)*255).astype('uint8'))
img.value = frame._repr_png_()
now = time.time()
if now < start_time+t:
time.sleep(start_time+t-now)
def __init__(self, camera, **kwargs):
super().__init__()
self.camera = camera
if "max_width" not in kwargs:
kwargs["max_width"] = "100%"
if "height" not in kwargs:
kwargs["height"] = "auto"
if "width" not in kwargs:
kwargs["width"] = "500px"
self.widget = Image(layout=Layout(**kwargs))
self.widget.add_class("pixelated")
# Update and draw:
self.draw()
def test_serialize():
fstream = io.BytesIO(b'123')
img = Image.from_file(fstream)
img_state = img.get_state()
# for python27 it is a memoryview
assert isinstance(img_state['value'], (bytes, memoryview))
# make sure it is (for python 3), since that is what it will be once it comes off the wire
img_state['value'] = memoryview(img_state['value'])
# check that we can deserialize it and get back the original value
img_copy = Image()
img_copy.set_state(img_state)
assert img.value == img_copy.value
def test_serialize():
fstream = io.BytesIO(b'123')
img = Image.from_file(fstream)
img_state = img.get_state()
# for python27 it is a memoryview
assert isinstance(img_state['value'], (bytes, memoryview))
# make sure it is (for python 3), since that is what it will be once it comes off the wire
img_state['value'] = memoryview(img_state['value'])
# check that we can deserialize it and get back the original value
img_copy = Image()
img_copy.set_state(img_state)
assert img.value == img_copy.value
def draw_splash(self, canvas, x, y, scale):
if scale > 0.:
splash_canvas = Canvas(width=self.cell_pixels,
height=self.cell_pixels)
sprite = Image.from_file('images/splash_2.png')
with hold_canvas(splash_canvas):
pos_x = self.cell_pixels // 2
pos_y = self.cell_pixels // 2
# Choose a random rotation angle
# (but first set the rotation center with `translate`)
splash_canvas.translate(pos_x, pos_y)
splash_canvas.rotate(uniform(0., pi))
# scale the image
splash_canvas.scale(scale)
# Restore the canvas center
splash_canvas.translate(-pos_x, -pos_y)
# Draw the sprite
splash_canvas.draw_image(sprite, 0, 0)
x_px = x * self.cell_pixels + self.padding
y_px = y * self.cell_pixels + self.padding
canvas.draw_image(splash_canvas,
x_px,
y_px,
width=self.cell_pixels,
height=self.cell_pixels)
def interpret_complex_model(self, data_features, predicted_labels, interpretable_model=None):
# make interpretable model a decision tree by default
if interpretable_model == None:
from sklearn.tree import DecisionTreeClassifier
interpretable_model = DecisionTreeClassifier(random_state=0)
# fit interpretable model on complex model's predicted labels
# NOTE: random_state param has to be passed to get consistent tree output, but is an arbitrary number
# How do we know which tree is the 'correct' way that the UninterpretableModel is learning?
interpretable_model.fit(data_features, predicted_labels)
# visualize model
if isinstance(interpretable_model, DecisionTreeClassifier):
from sklearn.externals.six import StringIO
from IPython.display import Image
from sklearn.tree import export_graphviz
import pydotplus
dot_data = StringIO()
export_graphviz(interpretable_model, out_file=dot_data,
filled=True, rounded=True,
special_characters=True,
feature_names=list(data_features.columns))
graph = pydotplus.graph_from_dot_data(dot_data.getvalue())
return Image(graph.create_png())
def __init__(self, state: BBoxCanvasState, has_border: bool = False):
super().__init__()
self._state = state
self._start_point = ()
self.is_drawing = False
self.has_border = has_border
self.canvas_bbox_coords = {}
# do not stick bbox to borders
self.padding = 2
# Define each of the children...
self._image = Image(layout=Layout(display='flex',
justify_content='center',
align_items='center',
align_content='center'))
self.multi_canvas = MultiCanvas(len(BBoxLayer),
width=self._state.width,
height=self._state.height)
self.im_name_box = Label()
children = [VBox([self.multi_canvas, self.im_name_box])]
self.children = children
draw_bg(self.multi_canvas[BBoxLayer.bg])
# link drawing events
self.multi_canvas[BBoxLayer.drawing].on_mouse_move(self._update_pos)
self.multi_canvas[BBoxLayer.drawing].on_mouse_down(self._start_drawing)
self.multi_canvas[BBoxLayer.drawing].on_mouse_up(self._stop_drawing)
def helper_image(self: Core, *args):
filename: str = args[0]
x: int = int(args[1])
y: int = int(args[2])
w: int = int(args[3])
h: int = int(args[4])
key = (filename, abs(w), abs(h))
if key not in _loaded_images:
_loaded_images[key] = Canvas(width=abs(w), height=abs(h))
_loaded_images[key].draw_image(
Image.from_file(filename, width=abs(w), height=abs(h)), 0, 0,
abs(w), abs(h))
self.canvas.translate(x, y)
if w < 0:
self.canvas.scale(-1, 1)
if h < 0:
self.canvas.scale(1, -1)
self.canvas.draw_image(_loaded_images[key], 0, 0)
if h < 0:
self.canvas.scale(1, -1)
if w < 0:
self.canvas.scale(-1, 1)
self.canvas.translate(-x, -y)
def test_value_repr_length():
with get_logo_png() as LOGO_PNG:
with open(LOGO_PNG, 'rb') as f:
img = Image.from_file(f)
assert len(img.__repr__()) < 140
assert img.__repr__().endswith(")")
assert img.__repr__()[-5:-2] == '...'
def __init__(self, robot, size=100, show_robot=True):
super().__init__()
self.robot = robot
self.size = size
self.show_robot = show_robot
self.map = {}
self.attrs = [
"name", "x", "y", "direction", "stalled", "tvx", "tva", "state"
]
self.labels = [
"Name:",
"X:",
"Y:",
"Direction:",
"Stalled:",
"Trans vel:",
"Rotate vel:",
"State:",
]
widget = make_attr_widget(self.robot, self.map, None, self.attrs,
self.labels)
if self.show_robot:
image = Image(
layout=Layout(width="-webkit-fill-available", height="auto"))
widget.children = [image] + list(widget.children)
self.widget = widget
self.update()
self.draw()
def test_format_inference_filename():
with tempfile.NamedTemporaryFile(suffix='.svg', delete=False) as f:
name = f.name
f.close() # Allow tests to run on Windows
img = Image.from_file(name)
assert img.format == 'svg+xml'
def __init__(self, camera):
super().__init__()
self.camera = camera
self.widget = Image(
layout=Layout(width="-webkit-fill-available", height="auto"))
# Update and draw:
self.draw()
def test_format_inference_overridable():
with tempfile.NamedTemporaryFile(suffix='.svg', delete=False) as f:
name = f.name
f.close() # Allow tests to run on Windows
img = Image.from_file(name, format='gif')
assert img.format == 'gif'
def update(self):
"""
Update the canvas with a new image.
"""
canvas = self._canvas
self.create(self._currentFrame)
self.renderWindow.Render()
windowToImageFilter = vtk.vtkWindowToImageFilter()
windowToImageFilter.SetInput(self.renderWindow)
windowToImageFilter.Update()
writer = vtk.vtkPNGWriter()
writer.SetWriteToMemory(1)
writer.SetInputConnection(windowToImageFilter.GetOutputPort())
writer.Write()
data = memoryview(writer.GetResult()).tobytes()
image = Image(value=data)
canvas.draw_image(image)
super().update()
def draw_img(canvas, file, clear=False):
# draws resized image on canvas and returns scale used
with hold_canvas(canvas):
if clear:
canvas.clear()
sprite1 = Image.from_file(file)
width_canvas, height_canvas = canvas.width, canvas.height
width_img, height_img = get_image_size(file)
ratio_canvas = float(width_canvas) / height_canvas
ratio_img = float(width_img) / height_img
if ratio_img > ratio_canvas:
# wider then canvas, scale to canvas width
scale = width_canvas / width_img
else:
# taller then canvas, scale to canvas hight
scale = height_canvas / height_img
canvas.draw_image(sprite1,
0,
0,
width=width_img * min(1, scale),
height=height_img * min(1, scale))
return scale
def __init__(self, width, height):
super().__init__()
self.is_drawing = False
self._start_point = ()
self._image_scale = 1.0
self._bg_layer = 0
self._image_layer = 1
self._box_layer = 2
# Define each of the children...
self._image = Image(layout=Layout(display='flex',
justify_content='center',
align_items='center',
align_content='center'))
self._multi_canvas = MultiCanvas(3, width=width, height=height)
self._im_name_box = Label()
children = [VBox([self._multi_canvas, self._im_name_box])]
self.children = children
draw_bg(self._multi_canvas[self._bg_layer])
# link drawing events
self._multi_canvas[self._box_layer].on_mouse_move(self._update_pos)
self._multi_canvas[self._box_layer].on_mouse_down(self._start_drawing)
self._multi_canvas[self._box_layer].on_mouse_up(self._stop_drawing)
def Single_Zone(self, Zone, fig=None, offset=np.array([0, 0])):
w = self.margin
wall_width = self.wall_th * self.scale
Zone_w = (Zone.x_delta + 2 * w) * self.scale
Zone_h = (Zone.y_delta + 2 * w) * self.scale
canvas_w = Zone_w + 2 * wall_width
canvas_h = Zone_h + 2 * wall_width
w = w * self.scale
if fig == None:
canvas = MultiCanvas(4, width=canvas_w, height=canvas_h)
else:
canvas = fig
# background
canvas[0].translate(offset[0], offset[1])
Mars_img = Image.from_file('Images/Mars_surface.jpg')
canvas3 = Canvas(width=1000, height=1000)
canvas3.draw_image(Mars_img, 0, 0)
canvas3.scale(3 * self.scale / 50)
canvas[0].draw_image(canvas3, 0, 0)
canvas[0].translate(-offset[0], -offset[1])
# Draw Zone
canvas[1].translate(offset[0], offset[1])
canvas[1].fill_rect(0, 0, canvas_w, height=canvas_h)
canvas[1].clear_rect(wall_width, wall_width, Zone_w, height=Zone_h)
# Name of thr Zone
canvas[1].font = '16px serif'
canvas[1].fill_text(Zone.name, Zone_w / 2, 4 * wall_width)
canvas[1].translate(-offset[0], -offset[1])
# Draw object insised the Zone
canvas[2].translate(offset[0], offset[1])
if Zone.type == 'Landing_zone':
charging = self.problem_2_canvas(Zone.charger)
trash_bin = self.problem_2_canvas(Zone.deposit)
canvas[2].fill_style = 'green'
canvas[2].fill_rect(charging[0] - w / 2, charging[1] - w / 2, w)
canvas[2].fill_style = 'blue'
canvas[2].fill_rect(trash_bin[0] - w / 2, trash_bin[1] - w / 2, w)
else:
canvas[2].fill_style = 'brown'
p_r = 0.1
x, y, radius = [], [], []
for i in range(0, Zone.max_sample):
sam_coord = self.problem_2_canvas(Zone.samples_loc[i, :])
x.append(sam_coord[0])
y.append(sam_coord[1])
radius.append(p_r * self.scale)
canvas[2].fill_circles(x, y, radius)
for i in Zone.connections['Location']:
canvas[2].fill_style = 'red'
c_coord = self.problem_2_canvas(Zone.Location_2_coordinate[i])
x = c_coord[0]
y = c_coord[1]
canvas[2].fill_rect(x - w / 2, y - w / 2, w)
canvas[2].translate(-offset[0], -offset[1])
return canvas
def load_sprites(self):
' load the sprite sheet and when loaded callback to split it into individual sprites '
sprites = Image.from_file('images/BabyRobot64_Sprites.png')
self.sprite_canvas = Canvas(width=132,
height=328,
sync_image_data=True)
self.sprite_canvas.draw_image(sprites, 0, 0)
self.sprite_canvas.observe(self.get_array, 'image_data')
def widget(self):
if hasattr(self, '_widget'):
return self._widget # cache widget, so we don't duplicate links
from ipywidgets import Image
from jetbot.image import bgr8_to_jpeg
image = Image()
traitlets.dlink((self, 'value'), (image, 'value'), transform=bgr8_to_jpeg)
self._widget = image
return image
def add_tool(self, tool):
self.tools[tool.tool_id] = tool
icon = Image.from_file(icon_path(tool.icon, icon_format='svg'),
width=ICON_WIDTH)
button = ToggleButton(children=[icon], value=tool.tool_id)
if self.children is None:
self.children = (button, )
else:
self.children = tuple(self.children) + (button, )
def on_click(change):
stylised_img = stylise(image=images_widget.image,
style=styles_widget.image)
stylised_widget = Image(value=to_binary(stylised_img),
width=stylised_img.size[0],
height=stylised_img.size[1],
format='png')
stylised_box = HBox(children=[stylised_widget],
layout=Layout(justify_content='space-around'))
full_display.children = [selectors, confirm_box, stylised_box]
def render(self, resp: requests.models.Response) -> Image:
"Return an ipywidget image with the data object rendered on it, or None."
obj = resp.content
ct = resp.headers['Content-Type']
maintype, subtype, params = re.match('(\w+)/([\.\+\w]+)(;.*)?',
ct).groups()
img = Image(value=obj, format=subtype)
self.data = img
return img
def create_qrcode(value, size=50):
d = Drawing(size, size)
qr = QrCodeWidget(value=value, barWidth=size, barHeight=size)
d.add(qr)
return Image(
value=renderPM.drawToString(d, fmt="png"),
format='png',
width=size,
height=size,
)
def __init__(self,
structure=None,
representations=None,
parameters=None,
**kwargs):
super(NGLWidget, self).__init__(**kwargs)
self._gui = None
self._init_gui = kwargs.pop('gui', False)
self._theme = kwargs.pop('theme', 'default')
self._widget_image = Image()
self._widget_image.width = 900.
self._image_array = []
# do not use _displayed_callbacks since there is another Widget._display_callbacks
self._event = threading.Event()
self._ngl_displayed_callbacks_before_loaded = []
self._ngl_displayed_callbacks_after_loaded = []
widget_utils._add_repr_method_shortcut(self, self)
self.shape = Shape(view=self)
self.stage = Stage(view=self)
self.control = ViewerControl(view=self)
self._handle_msg_thread = threading.Thread(
target=self.on_msg, args=(self._ngl_handle_msg, ))
# # register to get data from JS side
self._handle_msg_thread.daemon = True
self._handle_msg_thread.start()
self._remote_call_thread = RemoteCallThread(
self, registered_funcs=['loadFile', 'replaceStructure'])
self._remote_call_thread.start()
self._trajlist = []
self._ngl_component_ids = []
if parameters:
self.parameters = parameters
if isinstance(structure, Trajectory):
name = py_utils.get_name(structure, kwargs)
self.add_trajectory(structure, name=name)
elif isinstance(structure, (list, tuple)):
trajectories = structure
for trajectory in trajectories:
name = py_utils.get_name(trajectory, kwargs)
self.add_trajectory(trajectory, name=name)
else:
if structure is not None:
self.add_structure(structure, **kwargs)
if representations:
self.representations = representations
self._set_unsync_camera()
selector = 'nglviewHolder' + str(id(self))
self._remote_call('setSelector', target='Widget', args=[
selector,
])
self.player = TrajectoryPlayer(self)
self._already_constructed = True
def from_file(cls, filename, **kwargs):
"""Create a `ImageStream` from a local file.
Parameters
----------
filename: str
The location of a file to read into the value from disk.
**kwargs
Extra keyword arguments for `ImageStream`
"""
return cls(image=Image.from_file(filename), **kwargs)
def show_ensemble_model(Job_Name):
ensemblemodel_fname = f"./tmp/{Job_Name}/ensemble-model.png"
if os.path.exists(ensemblemodel_fname):
show_in_html("Ensemble model architecture", "#ff9900")
img_file = open(ensemblemodel_fname, "rb")
image = img_file.read()
widget_img = Image(value=image, format="png")
display(widget_img)
def show_ensemble_model(Job_Name):
ensemblemodel_fname = f'./tmp/{Job_Name}/ensemble-model.png'
if os.path.exists(ensemblemodel_fname):
show_in_html('Ensemble model architecture', '#ff9900')
img_file = open(ensemblemodel_fname, 'rb')
image = img_file.read()
widget_img = Image(value=image, format='png')
display(widget_img)
def __init__(self, scene_proxy, bridge, *args, **kw):
super(IPyRemoteWidget, self).__init__(scene_proxy, bridge, *args, **kw)
self.image = Image(format='PNG')
self.event = Event(source=self.image,
watched_events=[
'dragstart', 'mouseenter', 'mouseleave',
'mousedown', 'mouseup', 'mousemove', 'wheel',
'keyup', 'keydown'
],
prevent_default_action=True)
self.event.on_dom_event(self.handle_ipyevent)
self._update_image()
def create_layout(self):
title = HTML('<h1>Color Viewer</h1>')
self.img = Image(width=700, height=600)
self.img.layout.visibility = 'hidden'
rows = []
row1 = HBox([title], layout={'justify_content': 'flex-start'})
row2 = HBox([cmap_dropdown, self.img],
layout={'align_items': 'center'})
rows = [row1, row2]
return VBox(rows)
def add_tool(self, tool):
self.tools[tool.tool_id] = tool
icon = Image.from_file(icon_path(tool.icon, icon_format='svg'), width=ICON_WIDTH)
button = v.Btn(v_on="tooltip.on", icon=True, children=[icon], value=tool.tool_id)
annotated = v.Tooltip(
bottom=True,
v_slots=[{
'name': 'activator',
'variable': 'tooltip',
'children': button}],
children=[tool.tool_tip])
self.children = list(self.children) + [annotated]
def test_from_url_bytes():
img = Image.from_url(b'https://jupyter.org/assets/main-logo.svg')
assert img.value == b'https://jupyter.org/assets/main-logo.svg'
def test_set_value_from_file():
img = Image()
with get_logo_png() as LOGO_PNG:
with open(LOGO_PNG, 'rb') as f:
img.set_value_from_file(f)
assert_equal_hash(img.value, LOGO_PNG_DIGEST)
def test_set_from_filename():
img = Image()
with get_logo_png() as LOGO_PNG:
img.set_value_from_file(LOGO_PNG)
assert_equal_hash(img.value, LOGO_PNG_DIGEST)
def test_value_repr_url():
img = Image.from_url(b'https://jupyter.org/assets/main-logo.svg')
assert 'https://jupyter.org/assets/main-logo.svg' in img.__repr__()
def test_value_repr_length():
with get_logo_png() as LOGO_PNG:
with open(LOGO_PNG, 'rb') as f:
img = Image.from_file(f)
assert len(img.__repr__()) < 120
assert img.__repr__().endswith("...')")
def test_format_inference_stream():
# There's no way to infer the format, so it should default to png
fstream = io.BytesIO(b'')
img = Image.from_file(fstream)
assert img.format == 'png'
def test_format_inference_file():
with tempfile.NamedTemporaryFile(suffix='.gif', delete=False) as f:
img = Image.from_file(f)
assert img.format == 'gif'
