def _draw_classical_double_line(drawing: Drawing, x1_coord: int, y1_coord: int, x2_coord: int, y2_coord: int) -> None: """Draw a double line between (x1_coord, y1_coord) and (x2_coord, y2_coord). :param drawing: Drawing that will be used to draw. :param x1_coord: x-coordinate of the first point. :param y1_coord: y-coordinate of the first point. :param x2_coord: x-coordinate of the second point. :param y2_coord: y-coordinate of the second point. :raise NotImplementedError: when x1_coord != x2_coord and y1_coord != y2_coord (i.e. when the line is neither horizontal nor vertical). """ x_increment, y_increment = 0, 0 if x1_coord == x2_coord: x_increment = _constants.DOUBLE_LINES_SEPARATION elif y1_coord == y2_coord: y_increment = _constants.DOUBLE_LINES_SEPARATION else: raise NotImplementedError("The drawn line should be either horizontal " "or vertical.") drawing.add( drawing.line(start=(x1_coord - x_increment, y1_coord - y_increment), end=(x2_coord - x_increment, y2_coord - y_increment), stroke=_constants.GATE_BORDER_COLOR, stroke_width=_constants.STROKE_THICKNESS)) drawing.add( drawing.line(start=(x1_coord + x_increment, y1_coord + y_increment), end=(x2_coord + x_increment, y2_coord + y_increment), stroke=_constants.GATE_BORDER_COLOR, stroke_width=_constants.STROKE_THICKNESS))
def plot(self, x, y, scale, **extra): assert isinstance(scale, (int, float)) assert isinstance(x, (int, float)) assert isinstance(y, (int, float)) svg = Drawing() g = svg.g() p1 = [x, y] p2 = [x + max(self.ticks) * scale, y] g.add(svg.line(start=p1, end=p2, stroke="black", stroke_width=1)) for i, tick in enumerate(self.ticks): p1 = [x + tick * scale, y - 5] p2 = [x + tick * scale, y + 0.5] g.add(svg.line(start=p1, end=p2, stroke="black", stroke_width=1)) g.add( svg.text(text="%s" % self.labels[i], insert=[x + tick * scale, y + 10], font_size=8, font_family="Arial")) return g
def _draw_cnot_cross(drawing: Drawing, x_coord: float, y_coord: float) -> None: # Draw the circle _draw_gate_circle(drawing, x_coord, y_coord) # Draw the cross drawing.add(drawing.line(start=(x_coord - _constants.GATE_SIZE/2, y_coord), end=(x_coord + _constants.GATE_SIZE/2, y_coord), stroke=_constants.GATE_BORDER_COLOR, stroke_width=_constants.STROKE_THICKNESS)) drawing.add(drawing.line(start=(x_coord, y_coord - _constants.GATE_SIZE/2), end=(x_coord, y_coord + _constants.GATE_SIZE/2), stroke=_constants.GATE_BORDER_COLOR, stroke_width=_constants.STROKE_THICKNESS))
def make_lines(layer, drawing: svgwrite.Drawing, inpts): usage = {k: 0 for k in inpts} conn = 9 preferred_dist = 5 used_pairs = set([]) inpts.sort(key=lambda x: distance((page_width / 2, page_height / 2), x)) while len([True for k in inpts if usage[k] < conn]) > 1: available = [k for k in inpts if usage[k] < conn] startpt = available[0] endpts = [ k for k in available if k != startpt and (startpt, k) not in used_pairs and k[0] != startpt[0] and k[1] != startpt[1] ] if len(endpts) == 0: usage[startpt] += 1 continue endpt = min(endpts, key=lambda x: abs(preferred_dist - distance(x, startpt))) usage[startpt] += 1 usage[endpt] += 1 preferred_dist = preferred_dist used_pairs.add((endpt, startpt)) used_pairs.add((startpt, endpt)) if distance(startpt, endpt) < 100: layer.add( drawing.line(startpt, endpt, stroke=svgwrite.rgb(10, 10, 16, '%'), stroke_width=5, stroke_linecap='round', stroke_opacity=1.0))
def slice_file(image_position_patient_array, image_orientation_patient, output_path=None, input_path=None): print("Status: Loading File.") model = STLModel(input_path) stats = model.stats() print(stats) print("Status: Calculating Slices") v1 = Point3D(image_orientation_patient[0][0], image_orientation_patient[0][1], image_orientation_patient[0][2]) v2 = Point3D(image_orientation_patient[1][0], image_orientation_patient[1][1], image_orientation_patient[1][2]) org = Point3D(0, 0, 0) for i, slice_loc in enumerate(image_position_patient_array): slice_loc = Point3D(slice_loc[0], slice_loc[1], slice_loc[2]) dwg = Drawing(output_path + str(i) + '.svg', profile='tiny') plane = Plane(v1 + slice_loc, v2 + slice_loc, org + slice_loc) x_axis = Line(org + slice_loc, v1 + slice_loc) y_axis = Line(org + slice_loc, v2 + slice_loc) pairs = model.slice_at_plane(plane, x_axis, y_axis) for pair in pairs: dwg.add(dwg.line(pair[0], pair[1], stroke=rgb(0, 0, 0, "%"))) dwg.save() print("Status: Finished Outputting Slices")
def _draw_line_between_qubits(drawing: Drawing, bit_gate_rank: _types.BitRankType, control_qubit: int, target_qubit: int, bit_mapping: dict, index_to_draw: int = None) -> None: """Draw a line between the two given qubits. :param drawing: Drawing that will be used to draw. :param bit_gate_rank: Structure used to keep track of the used and free places. See module docstring for more information. :param control_qubit: First qubit. :param target_qubit: Second qubit. :param bit_mapping: Unused at the moment. :param index_to_draw: If precised, force the line to be drawn at the given index. Else, the index is computed and the line drawn at the first free place possible. """ if index_to_draw is None: index_to_draw, _ = _helpers.get_max_index(bit_gate_rank, qubits=[control_qubit, target_qubit]) x_coord = _helpers.get_x_from_index(index_to_draw) y1_coord = _helpers.get_y_from_quantum_register(control_qubit, bit_mapping) y2_coord = _helpers.get_y_from_quantum_register(target_qubit, bit_mapping) drawing.add(drawing.line(start=(x_coord, y1_coord), end=(x_coord, y2_coord), stroke=_constants.GATE_BORDER_COLOR, stroke_width=_constants.STROKE_THICKNESS))
def _draw_swap_cross(drawing: Drawing, x_coord: float, y_coord: float) -> None: start_bl_tr = tuple((x_coord - _constants.GATE_SIZE / 2, y_coord - _constants.GATE_SIZE / 2)) end_bl_tr = tuple((x_coord + _constants.GATE_SIZE / 2, y_coord + _constants.GATE_SIZE / 2)) # Draw the cross drawing.add(drawing.line(start=start_bl_tr, end=end_bl_tr, stroke=_constants.GATE_BORDER_COLOR, stroke_width=_constants.STROKE_THICKNESS)) start_br_tl = tuple((x_coord + _constants.GATE_SIZE / 2, y_coord - _constants.GATE_SIZE / 2)) end_br_tl = tuple((x_coord - _constants.GATE_SIZE / 2, y_coord + _constants.GATE_SIZE / 2)) drawing.add(drawing.line(start=start_br_tl, end=end_br_tl, stroke=_constants.GATE_BORDER_COLOR, stroke_width=_constants.STROKE_THICKNESS))
def generate_frame(i, j, k): filename = str(i)+str(j)+str(k)+".svg" dwg = Drawing(filename, size=(300, 300)) dwg.add(dwg.text('i = %d, j = %d, k %d' % (i, j, k), insert=(0.5, 20), fill='red')) dwg.add(dwg.line((0, 0), (10, 0), stroke=rgb(10, 10, 16, '%'))) dwg.save() pixel_width = 300 return convert(pixel_width, filename)
def draw_svg(self, drawing: svgwrite.Drawing, g): glane = drawing.g() glane.attribs["class"] = "lane" cp1 = self.control_points[0] cp2 = self.control_points[-1] rel = relative_pose(cp1.as_SE2(), cp2.as_SE2()) _, theta = geo.translation_angle_from_SE2(rel) delta = int(np.sign(theta)) fill = {-1: "#577094", 0: "#709457", 1: "#947057"}[delta] points = self.lane_profile(points_per_segment=10) p = drawing.polygon(points=points, fill=fill, fill_opacity=0.5) glane.add(p) center_points = self.center_line_points(points_per_segment=10) center_points = [ geo.translation_angle_from_SE2(_)[0] for _ in center_points ] p = drawing.polyline( points=center_points, stroke=fill, fill="none", stroke_dasharray="0.02", stroke_width=0.01, ) glane.add(p) g.add(glane) for x in self.control_points: q = x.asmatrix2d().m p1, _ = geo.translation_angle_from_SE2(q) delta_arrow = np.array([self.width / 4, 0]) p2 = SE2_apply_R2(q, delta_arrow) gp = drawing.g() gp.attribs["class"] = "control-point" l = drawing.line( start=p1.tolist(), end=p2.tolist(), stroke="black", stroke_width=self.width / 20.0, ) gp.add(l) c = drawing.circle( center=p1.tolist(), r=self.width / 8, fill="white", stroke="black", stroke_width=self.width / 20.0, ) gp.add(c) g.add(gp)
def _draw_registers_names_and_lines(drawing: Drawing, circuit_width: int, json_circuit: str, show_clbits: bool) -> None: # First we draw the names of each register qubit_labels = json_circuit['header'].get('qubit_labels', []) clbit_labels = json_circuit['header'].get('clbit_labels', []) if show_clbits else [] ## 1. Compute the font size that will be used to keep good dimensions font_size = _constants.REGISTER_NAME_FONT_SIZE for qubit_label in itertools.chain(qubit_labels, clbit_labels): qubit_text_name = "{}[{}]".format(*qubit_label) desired_width = (_constants.REGISTER_NAME_WIDTH - _constants.REGISTER_NAME_LEFT_BORDER - _constants.REGISTER_NAME_RIGHT_BORDER) adapted_font_size = _helpers.adapt_text_font_size(qubit_text_name, desired_width, _constants.MAX_REGISTER_NAME_HEIGHT) font_size = min(font_size, adapted_font_size) ## 2. Draw the bit names y_coord = _constants.VERTICAL_BORDER for bit_label in itertools.chain(qubit_labels, clbit_labels): qubit_text_name = "{}[{}]".format(*bit_label) drawing.add( drawing.text( qubit_text_name, insert=(_constants.REGISTER_NAME_WIDTH - _constants.REGISTER_NAME_RIGHT_BORDER, y_coord + _constants.FONT_SIZE_CENTER_VERTICALLY_MULTIPLIER * font_size), text_anchor="end", font_size=font_size ) ) y_coord += _constants.REGISTER_LINES_VERTICAL_SPACING # Then we draw the register lines y_coord = _constants.VERTICAL_BORDER # Start with quantum registers quantum_register_number = json_circuit['header'].get('number_of_qubits', 0) for _ in range(quantum_register_number): drawing.add(drawing.line(start=(_constants.REGISTER_NAME_WIDTH, y_coord), end=(circuit_width, y_coord), stroke=_constants.GATE_BORDER_COLOR, stroke_width=_constants.STROKE_THICKNESS)) y_coord += _constants.REGISTER_LINES_VERTICAL_SPACING # And see if we want to plot classical registers. if show_clbits: classical_register_number = json_circuit['header'].get('number_of_clbits', 0) for _ in range(classical_register_number): _draw_classical_double_line(drawing, _constants.REGISTER_NAME_WIDTH, y_coord, circuit_width, y_coord) y_coord += _constants.REGISTER_LINES_VERTICAL_SPACING
def slice_file(f=None, resolution=0.1): print("Status: Loading File.") model = STLModel(f) scale = 10 stats = model.stats() sub_vertex = Vector3(stats['extents']['x']['lower'], stats['extents']['y']['lower'], stats['extents']['z']['lower']) add_vertex = Vector3(0.5, 0.5, 0.5) model.xmin = model.xmax = None model.ymin = model.ymax = None model.zmin = model.zmax = None print("Status: Scaling Triangles.") for triangle in model.triangles: triangle.vertices[0] -= sub_vertex triangle.vertices[1] -= sub_vertex triangle.vertices[2] -= sub_vertex # The lines above have no effect on the normal. triangle.vertices[0] = (triangle.vertices[0] * scale) + add_vertex triangle.vertices[1] = (triangle.vertices[1] * scale) + add_vertex triangle.vertices[2] = (triangle.vertices[2] * scale) + add_vertex # Recalculate the triangle normal u = model.triangles[0].vertices[1] - model.triangles[0].vertices[0] v = model.triangles[0].vertices[2] - model.triangles[0].vertices[0] triangle.n = Normal((u.y * v.z) - (u.z * v.y), (u.z * v.x) - (u.x * v.z), (u.x * v.y) - (u.y * v.x)) model.update_extents(triangle) print("Status: Calculating Slices") interval = scale * resolution stats = model.stats() print(stats) for targetz in range(0, int(stats['extents']['z']['upper']), int(interval)): dwg = Drawing('outputs/svg/' + str(targetz) + '.svg', profile='tiny') pairs = model.slice_at_z(targetz) for pair in pairs: dwg.add(dwg.line(pair[0], pair[1], stroke=rgb(0, 0, 0, "%"))) dwg.save() print("Status: Finished Outputting Slices")
def _draw_cnot_cross(drawing: Drawing, x_coord: float, y_coord: float) -> None: """Draw the cross of a CX gate with the circle around. :param drawing: Drawing that will be used to draw. :param x_coord: x-coordinate of the crossing point. :param y_coord: y-coordinate of the crossing point. """ # Draw the circle _draw_gate_circle(drawing, x_coord, y_coord) # Draw the cross drawing.add( drawing.line(start=(x_coord - _constants.GATE_SIZE / 2, y_coord), end=(x_coord + _constants.GATE_SIZE / 2, y_coord), stroke=_constants.GATE_BORDER_COLOR, stroke_width=_constants.STROKE_THICKNESS)) drawing.add( drawing.line(start=(x_coord, y_coord - _constants.GATE_SIZE / 2), end=(x_coord, y_coord + _constants.GATE_SIZE / 2), stroke=_constants.GATE_BORDER_COLOR, stroke_width=_constants.STROKE_THICKNESS))
def display_svg(): dwg = Drawing() hlines = dwg.add(dwg.g(id="hlines", stroke="green")) for y in range(20): hlines.add( dwg.line(start=(2 * cm, (2 + y) * cm), end=(18 * cm, (2 + y) * cm))) vlines = dwg.add(dwg.g(id="vline", stroke="blue")) for x in range(17): vlines.add( dwg.line(start=((2 + x) * cm, 2 * cm), end=((2 + x) * cm, 21 * cm))) shapes = dwg.add(dwg.g(id="shapes", fill="red")) # set presentation attributes at object creation as SVG-Attributes circle = dwg.circle(center=(15 * cm, 8 * cm), r="2.5cm", stroke="blue", stroke_width=3) circle["class"] = "class1 class2" shapes.add(circle) # override the 'fill' attribute of the parent group 'shapes' shapes.add( dwg.rect( insert=(5 * cm, 5 * cm), size=(45 * mm, 45 * mm), fill="blue", stroke="red", stroke_width=3, )) # or set presentation attributes by helper functions of the Presentation-Mixin ellipse = shapes.add( dwg.ellipse(center=(10 * cm, 15 * cm), r=("5cm", "10mm"))) ellipse.fill("green", opacity=0.5).stroke("black", width=5).dasharray([20, 20]) return Response(dwg.tostring(), mimetype="image/svg+xml")
def _draw_classical_double_line(drawing: Drawing, x1_coord, y1_coord, x2_coord, y2_coord) -> None: """Draw a double line between (x1_coord,y1_coord) and (x2_coord,y2_coord). Raises: NotImplementedError: when x1_coord!=x2_coord and y1_coord!=y2_coord (i.e. when the line is neither horizontal nor vertical). """ x_increment, y_increment = 0, 0 if x1_coord == x2_coord: x_increment = _constants.DOUBLE_LINES_SEPARATION elif y1_coord == y2_coord: y_increment = _constants.DOUBLE_LINES_SEPARATION else: raise NotImplementedError("The drawed line should be either horizontal or vertical.") drawing.add(drawing.line(start=(x1_coord - x_increment, y1_coord - y_increment), end=(x2_coord - x_increment, y2_coord - y_increment), stroke=_constants.GATE_BORDER_COLOR, stroke_width=_constants.STROKE_THICKNESS)) drawing.add(drawing.line(start=(x1_coord + x_increment, y1_coord + y_increment), end=(x2_coord + x_increment, y2_coord + y_increment), stroke=_constants.GATE_BORDER_COLOR, stroke_width=_constants.STROKE_THICKNESS))
def make_lines2(layer, drawing: svgwrite.Drawing, inpts): tail = inpts while len(tail) > 1: head, *tail = tail minpt = min(tail, key=lambda x: distance(x, head)) if not in_circle(circle_radius, mid_point( head, minpt)) and distance(minpt, head) < 15: layer.add( drawing.line(head, minpt, stroke=svgwrite.rgb(255, 10, 16, '%'), stroke_width=8, stroke_linecap='round'))
def _draw_line_between_qubits(drawing: Drawing, bit_gate_rank: BitRankType, control_qubit: int, target_qubit: int, bit_mapping: dict, index_to_draw: int = None) -> None: if index_to_draw is None: index_to_draw, _ = _helpers.get_max_index(bit_gate_rank, qubits=[control_qubit, target_qubit]) x_coord = _helpers.get_x_from_index(index_to_draw) y1_coord = _helpers.get_y_from_quantum_register(control_qubit, bit_mapping) y2_coord = _helpers.get_y_from_quantum_register(target_qubit, bit_mapping) drawing.add(drawing.line(start=(x_coord, y1_coord), end=(x_coord, y2_coord), stroke=_constants.GATE_BORDER_COLOR, stroke_width=_constants.STROKE_THICKNESS))
def _draw_year(self, d: svgwrite.Drawing, size: XY, offset: XY, year: int): min_size = min(size.x, size.y) outer_radius = 0.5 * min_size - 6 radius_range = ValueRange.from_pair(outer_radius / 4, outer_radius) center = offset + 0.5 * size if self._rings: self._draw_rings(d, center, radius_range) year_style = 'dominant-baseline: central; font-size:{}px; font-family:Arial;'.format(min_size * 4.0 / 80.0) month_style = 'font-size:{}px; font-family:Arial;'.format(min_size * 3.0 / 80.0) d.add(d.text('{}'.format(year), insert=center.tuple(), fill=self.poster.colors['text'], text_anchor="middle", alignment_baseline="middle", style=year_style)) df = 360.0 / (366 if calendar.isleap(year) else 365) day = 0 date = datetime.date(year, 1, 1) while date.year == year: text_date = date.strftime("%Y-%m-%d") a1 = math.radians(day * df) a2 = math.radians((day + 1) * df) if date.day == 1: (_, last_day) = calendar.monthrange(date.year, date.month) a3 = math.radians((day + last_day - 1) * df) sin_a1, cos_a1 = math.sin(a1), math.cos(a1) sin_a3, cos_a3 = math.sin(a3), math.cos(a3) r1 = outer_radius + 1 r2 = outer_radius + 6 r3 = outer_radius + 2 d.add(d.line( start=(center + r1 * XY(sin_a1, -cos_a1)).tuple(), end=(center + r2 * XY(sin_a1, -cos_a1)).tuple(), stroke=self.poster.colors['text'], stroke_width=0.3)) path = d.path(d=('M', center.x + r3 * sin_a1, center.y - r3 * cos_a1), fill='none', stroke='none') path.push('a{},{} 0 0,1 {},{}'.format(r3, r3, r3 * (sin_a3 - sin_a1), r3 * (cos_a1 - cos_a3))) d.add(path) tpath = svgwrite.text.TextPath(path, date.strftime("%B"), startOffset=(0.5 * r3 * (a3 - a1))) text = d.text("", fill=self.poster.colors['text'], text_anchor="middle", style=month_style) text.add(tpath) d.add(text) if text_date in self.poster.tracks_by_date: self._draw_circle_segment(d, self.poster.tracks_by_date[text_date], a1, a2, radius_range, center) day += 1 date += datetime.timedelta(1)
def add(self, svg: Drawing) -> None: a: np.array = to_grid(self.point1) b: np.array = to_grid(self.point2) n = (b - a) / np.linalg.norm((b - a)) na = a + (n * self.radius) nb = b - (n * self.radius) line = svg.line(na, nb, stroke_width=0.5, fill="none", stroke="black") if not self.is_feasible: line.update({"stroke-dasharray": "1,1"}) svg.add(line) v = svg.path(d=create_v(nb, n, np.dot(rotation_matrix(-math.pi / 2.0), n)), stroke_width=0.5, fill="none", stroke="black") if not self.is_feasible: v.update({"stroke-dasharray": "1,1"}) svg.add(v)
val = col.iloc[j] y = vertplace(j, col) if i == 0: txt = g.add( dwg.text(collabels.iloc[j] + tabpad + str(val), insert=(collocs[i], h - y), text_anchor='end', font_size="%ipx" % fontsize)) elif i == ncols - 1: txt = g.add( dwg.text(str(val) + tabpad + collabels.iloc[j], insert=(collocs[i], h - y), font_size="%ipx" % fontsize)) else: txt = g.add( dwg.text(str(val), insert=(collocs[i], h - y), font_size="%ipx" % fontsize)) ys[collabels.iloc[j]].append(y) if i > 0: line = g.add( dwg.line((collocs[i - 1] + textpad, h - ys[collabels.iloc[j]][i - 1]), (collocs[i] - textpad, h - ys[collabels.iloc[j]][i]), stroke_width=1, stroke='black')) dwg.save()
def plot(self, svg: Drawing) -> None: recolor: Optional[str] = None if isinstance(self.color, list): linear_gradient: LinearGradient = svg.linearGradient( self.map_((0, self.max_y)), self.map_((0, 1)), gradientUnits="userSpaceOnUse", ) for index, color in enumerate(self.color): linear_gradient.add_stop_color( index / (len(self.color) - 1), color.hex ) gradient: LinearGradient = svg.defs.add(linear_gradient) recolor = gradient.get_funciri() if isinstance(self.color, Color): recolor = self.color.hex svg.add( svg.rect( insert=(0, 0), size=("100%", "100%"), rx=None, ry=None, fill=self.background_color.hex, ) ) self.draw_grid(svg) last_text_y = 0 for xs, ys, color, title in self.data: if recolor: color = recolor assert len(xs) == len(ys) xs_second: list[float] = [ (x - self.min_x).total_seconds() for x in xs ] points = [] for index, x in enumerate(xs_second): y = ys[index] mapped: np.ndarray = map_array( np.array((x, y)), np.array((self.min_x_second, self.max_y)), np.array((self.max_x_second, self.min_y)), self.canvas.workspace[0], self.canvas.workspace[1], ) points.append(mapped) previous_point: Optional[np.ndarray] = None for point in points: if previous_point is not None: line: Line = svg.line( (previous_point[0], previous_point[1]), (point[0], point[1]), stroke=self.background_color.hex, stroke_width=6, ) svg.add(line) line: Line = svg.line( (previous_point[0], previous_point[1]), (point[0], point[1]), stroke=color, stroke_width=2, ) svg.add(line) previous_point = point for point in points: svg.add( svg.circle( (point[0], point[1]), 5.5, fill=self.background_color.hex, ) ) svg.add(svg.circle((point[0], point[1]), 3.5, fill=color)) title: str text_y = max(last_text_y + 20, point[1] + 6) self.text(svg, (point[0] + 15, text_y), title.upper(), color) last_text_y = text_y with Path(svg.filename).open("w+") as output_file: svg.write(output_file)
for loc in locs: top_text.add(dwg.text(loc, (x - len(loc) * 4, y))) vertical_locs.append(x) x += delta_x legend_text = dwg.add( dwg.g(font_size=main_font_size, style="font-family: arial;")) legend_text.add(dwg.text('Phys', (x - 1500, y - 10), fill=color_phys)) legend_text.add(dwg.text('Scaled', (x - 1500, y + 20), fill=color_scaled)) v_lines = dwg.add(dwg.g(stroke_width=7.0, stroke=color_phys, fill='none')) v_lines_scaled = dwg.add( dwg.g(stroke_width=7.0, stroke=color_scaled, fill='none')) for loc in vertical_locs: v_lines.add(dwg.line(start=(loc, y + 15), end=(loc, 1300))) extra_text = dwg.add( dwg.g(font_size=main_font_size - 3, style="font-family: arial;")) extra_text.add(dwg.text('fwd mode', (150, 50))) extra_text.add(dwg.text('unit conversion', (vertical_locs[3] + 15, 870))) locs = [ ('Problem.compute_totals()', None, []), ('_TotalJacInfo.compute_totals()', None, []), ('System.scaled_context_all()', ((0, 2), (0, 3), (0, 5), (0, 6)), ['stagger']), ('Group._linearize()', None, []), (' ExplicitComponent._linearize()', None, []), (' ExplicitComponent._unscaled_context()', ((0, 2), (0, 3), (0, 5), (0, 6)), ['stagger']),
for loc in locs: top_text.add(dwg.text(loc, (x - len(loc) * 4, y))) vertical_locs.append(x) x += delta_x legend_text = dwg.add( dwg.g(font_size=main_font_size, style="font-family: arial;")) legend_text.add(dwg.text('Phys', (x - 300, y - 10), fill=color_phys)) legend_text.add(dwg.text('Scaled', (x - 300, y + 20), fill=color_scaled)) v_lines = dwg.add(dwg.g(stroke_width=7.0, stroke=color_phys, fill='none')) v_lines_scaled = dwg.add( dwg.g(stroke_width=7.0, stroke=color_scaled, fill='none')) for loc in vertical_locs: v_lines.add(dwg.line(start=(loc, y + 15), end=(loc, 1100))) extra_text = dwg.add( dwg.g(font_size=main_font_size - 3, style="font-family: arial;")) extra_text.add(dwg.text('Unit Conversion', (vertical_locs[0] + 10, 650))) locs = [ ('Problem.run_model()', None, []), ('Model.run_solve_nonlinear()', None, []), ('System.scaled_context_all()', ((0, 2), (0, 3)), []), ('System.solve_nonlinear()', None, []), ('NonlinearRunOnce.solve()', None, []), ('NonlinearRunOnce.gs_iter()', None, []), (' Group._transfer()', None, []), (" DefaultVector.scale('norm')", ((0, 1), ), []), (' DefaultTransfer.transfer()', ((2, 1), ), []),
delta_x = 400 vertical_locs = [] for loc in locs: top_text.add(dwg.text(loc, (x - len(loc)*4, y))) vertical_locs.append(x) x += delta_x legend_text = dwg.add(dwg.g(font_size=main_font_size, style="font-family: arial;")) legend_text.add(dwg.text('Phys', (x-300, y-10), fill=color_phys)) legend_text.add(dwg.text('Scaled', (x-300, y+20), fill=color_scaled)) v_lines = dwg.add(dwg.g(stroke_width=7.0, stroke=color_phys, fill='none')) v_lines_scaled = dwg.add(dwg.g(stroke_width=7.0, stroke=color_scaled, fill='none')) for loc in vertical_locs: v_lines.add(dwg.line(start=(loc, y+15), end=(loc, 1100))) extra_text = dwg.add(dwg.g(font_size=main_font_size - 3, style="font-family: arial;")) extra_text.add(dwg.text('Unit Conversion', (vertical_locs[0] + 10, 650))) locs = [('Problem.run_model()', None, []), ('Model.run_solve_nonlinear()', None, []), ('System.scaled_context_all()', ((0, 2), (0, 3)), []), ('System.solve_nonlinear()', None, []), ('NonlinearRunOnce.solve()', None, []), ('NonlinearRunOnce.gs_iter()', None, []), (' Group._transfer()', None, []), (" DefaultVector.scale('norm')", ((0, 1), ), []), (' DefaultTransfer.transfer()', ((2, 1), ), []), (" DefaultVector.scale('phys')", ((0, 1), ), []), (' ExplicitComponent.solve_nonlinear()', None, []),
def add_graphelement_to_svg_drawing(element: GraphElement, drawing: svgwrite.Drawing, filters: Dict[str, Filter]) -> None: args = {} for attr, value in element.attr.items(): if attr.startswith('.svg_tag'): continue if attr.startswith('.svg_'): name = attr[5:] if name == 'filter': args[name] = filters[value].get_funciri() else: args[name] = value if '.svg_tag' in element.attr: tag = element.attr['.svg_tag'] if tag == 'rect': x = float(element.attr['x']) y = -float(element.attr['y']) width = float(element.attr.get('.svg_width', 0.1)) height = float(element.attr.get('.svg_height', 0.1)) x = x - width / 2 y = y - height / 2 drawing.add(drawing.rect((x*mult, y*mult), (width*mult, height*mult), **args)) elif tag == 'path': drawing.add(drawing.path(**args)) elif tag == 'circle': x = float(element.attr['x']) y = -float(element.attr['y']) args.setdefault('r', '1cm') args.setdefault('stroke_width', '0.1mm') args.setdefault('stroke', 'black') args.setdefault('fill', 'none') drawing.add(drawing.circle(center=(x * mult, y * mult), **args)) elif tag == 'image': x = float(element.attr['x']) y = -float(element.attr['y']) width = float(element.attr.pop('.svg_width', 5)) height = float(element.attr.pop('.svg_height', 5)) x = x - width / 2 y = y - height / 2 center = ((x + width / 2), (y + height / 2)) args.setdefault('insert', (x * mult, y * mult)) args.setdefault('size', (width * mult, height * mult)) if '.svgx_rotate' in element.attr: rotation = float(element.attr['.svgx_rotate']) args.setdefault('transform', f'translate({center[0]*mult}, {center[1]*mult}) ' f'rotate({-rotation}) ' f'translate({-center[0]*mult}, {-center[1]*mult})' ) drawing.add(getattr(drawing, element.attr['.svg_tag'])(**args)) elif tag != 'None' and tag is not None: drawing.add(getattr(drawing, element.attr['.svg_tag'])(**args)) elif isinstance(element, Vertex): if '.helper_node' in element.attr and element.attr['.helper_node']: return x = float(element.attr['x']) y = -float(element.attr['y']) args.setdefault('r', '0.4cm') args.setdefault('stroke_width', '1mm') args.setdefault('stroke', 'black') args.setdefault('fill', 'none') drawing.add(drawing.circle(center=(x*mult, y*mult), **args)) elif isinstance(element, Edge): v1 = element.vertex1 v2 = element.vertex2 x1 = float(v1.attr['x']) y1 = -float(v1.attr['y']) x2 = float(v2.attr['x']) y2 = -float(v2.attr['y']) args.setdefault('stroke_width', '1mm') args.setdefault('stroke', 'black') drawing.add(drawing.line(start=(x1*mult, y1*mult), end=(x2*mult, y2*mult), **args)) else: raise ValueError
return prevy - fontsize else: return curry else: return scale(val) ys = {label: [] for label in labels} for i in range(ncols): col = cols.iloc[:,i] sort = argsort(col)[::-1] # descending---top to bottom col = col[sort] collabels = labels[sort] for j in range(len(col)): val = col.iloc[j] y = vertplace(j, col) if i==0: txt = g.add(dwg.text(collabels.iloc[j]+tabpad+str(val), insert=(collocs[i], h - y), text_anchor='end', font_size="%ipx" % fontsize)) elif i==ncols-1: txt = g.add(dwg.text(str(val)+tabpad+collabels.iloc[j], insert=(collocs[i], h - y), font_size="%ipx" % fontsize)) else: txt = g.add(dwg.text(str(val), insert=(collocs[i], h - y), font_size="%ipx" % fontsize)) ys[collabels.iloc[j]].append(y) if i > 0: line = g.add(dwg.line( (collocs[i-1]+textpad, h - ys[collabels.iloc[j]][i-1]), (collocs[i]-textpad, h - ys[collabels.iloc[j]][i]), stroke_width=1, stroke='black')) dwg.save()
def plot(self, x, y, scale, break_width=10, **extra): svg = Drawing() break_length = 0 fragments = self.get_fragments() g = svg.g() for i in range(len(fragments)): f = fragments[i] if i > 0: break_length += f.start - fragments[ i - 1].end - break_width / scale p1 = [x + (f.start - break_length) * scale, y] p2 = [x + (f.end - break_length) * scale, y] f.position = p1 line1 = svg.line(start=p1, end=p2, **extra) line2 = svg.line(start=[p1[0], p1[1] - 5], end=[p1[0], p1[1] + 5], **extra) text2 = svg.text(text=f.start, insert=(p1[0], p1[1] + 10), font_size=8, font_family="Arial", transform='rotate(%s, %s, %s)' % (90, p1[0], p1[1] + 10)) line3 = svg.line(start=[p2[0], p1[1] - 5], end=[p2[0], p1[1] + 5], **extra) text3 = svg.text(text=f.end, insert=(p2[0], p2[1] + 10), font_size=8, font_family="Arial", transform='rotate(%s, %s, %s)' % (90, p2[0], p1[1] + 10)) g.add(line1) g.add(line2) g.add(text2) g.add(line3) g.add(text3) text1 = svg.text(text=self.name, insert=(10, y), font_size=10, font_family="Arial") g.add(text1) text2 = svg.text(text="%s nt" % self.length, insert=(x / 2.0 - 10, y + 12), font_size=8, font_family="Arial") g.add(text2) for e in self.features: if e.frag_genome: patch, text = e.plot(scale=scale) g.add(patch) g.add(text) return g
paths_to_add = [p for p in paths_to_add if p[0] != path_to_add[0]] start_location = paths[path_to_add[0]].start if path_to_add[0] else paths[ path_to_add[1]].end ''' if __name__ == "__main__": # make a graph of the next available grid num_grid = 8 spacing = 30 dwg = Drawing(join(OUTPUT_DIRECTORY, "next_available_grid.svg"), (num_grid * spacing, num_grid * spacing)) for x in range(num_grid): dwg.add( dwg.line(start=(0, x * spacing), end=(num_grid * spacing, x * spacing), stroke=rgb(10, 10, 16, '%'))) dwg.add( dwg.line(start=(x * spacing, 0), end=(x * spacing, num_grid * spacing), stroke=rgb(10, 10, 16, '%'))) start_point = [4, 4] dwg.add( dwg.rect(insert=(start_point[0] * spacing, start_point[1] * spacing), size=(spacing, spacing), fill=rgb(100, 100, 16, '%'))) count = 0 last_point = start_point for next_available in NextAvailableGrid(*start_point): dwg.add(
delta_x = 180 vertical_locs = [] for loc in locs: top_text.add(dwg.text(loc, (x - len(loc)*4, y))) vertical_locs.append(x) x += delta_x legend_text = dwg.add(dwg.g(font_size=main_font_size, style="font-family: arial;")) legend_text.add(dwg.text('Phys', (x-1500, y-10), fill=color_phys)) legend_text.add(dwg.text('Scaled', (x-1500, y+20), fill=color_scaled)) v_lines = dwg.add(dwg.g(stroke_width=7.0, stroke=color_phys, fill='none')) v_lines_scaled = dwg.add(dwg.g(stroke_width=7.0, stroke=color_scaled, fill='none')) for loc in vertical_locs: v_lines.add(dwg.line(start=(loc, y+15), end=(loc, 1200))) extra_text = dwg.add(dwg.g(font_size=main_font_size - 3, style="font-family: arial;")) extra_text.add(dwg.text('fwd', (vertical_locs[5] + 55, 820))) locs = [('Problem.compute_totals()', None, []), ('_TotalJacInfo.compute_totals()', None, []), ('System.scaled_context_all()', ((0, 2), (0, 3), (0, 5), (0, 6)), ['stagger']), ('Group._linearize()', None, []), (' ExplicitComponent._linearize()', None, []), (' ExplicitComponent._unscaled_context()', ((0, 2), (0, 3), (0, 5), (0, 6)), ['stagger']), (' Paraboloid.compute_partials()', ((4, 7), ), []), (' ExplicitComponent._unscaled_context()', ((0, 2), (0, 3), (0, 5), (0, 6)), ['italic', 'stagger']), ('AssembledJacobian._update()', None, []), ('System.scaled_context_all()', ((0, 2), (0, 3), (0, 5), (0, 6)), ['italic', 'stagger']), ('DirectSolver._linearize()', None, []),
def _draw_year(self, dr: svgwrite.Drawing, g: svgwrite.container.Group, size: XY, offset: XY, year: int) -> None: min_size = min(size.x, size.y) outer_radius = 0.5 * min_size - 6 radius_range = ValueRange.from_pair(outer_radius / 4, outer_radius) center = offset + 0.5 * size if self._rings: self._draw_rings(dr, g, center, radius_range) year_style = f"dominant-baseline: central; font-size:{min_size * 4.0 / 80.0}px; font-family:Arial;" month_style = f"font-size:{min_size * 3.0 / 80.0}px; font-family:Arial;" g.add( dr.text( f"{year}", insert=center.tuple(), fill=self.poster.colors["text"], text_anchor="middle", alignment_baseline="middle", style=year_style, )) df = 360.0 / (366 if calendar.isleap(year) else 365) day = 0 date = datetime.date(year, 1, 1) while date.year == year: text_date = date.strftime("%Y-%m-%d") a1 = math.radians(day * df) a2 = math.radians((day + 1) * df) if date.day == 1: (_, last_day) = calendar.monthrange(date.year, date.month) a3 = math.radians((day + last_day - 1) * df) sin_a1, cos_a1 = math.sin(a1), math.cos(a1) sin_a3, cos_a3 = math.sin(a3), math.cos(a3) r1 = outer_radius + 1 r2 = outer_radius + 6 r3 = outer_radius + 2 g.add( dr.line( start=(center + r1 * XY(sin_a1, -cos_a1)).tuple(), end=(center + r2 * XY(sin_a1, -cos_a1)).tuple(), stroke=self.poster.colors["text"], stroke_width=0.3, )) path = dr.path( d=("M", center.x + r3 * sin_a1, center.y - r3 * cos_a1), fill="none", stroke="none", ) path.push( f"a{r3},{r3} 0 0,1 {r3 * (sin_a3 - sin_a1)},{r3 * (cos_a1 - cos_a3)}" ) g.add(path) tpath = svgwrite.text.TextPath( path, self.poster.month_name(date.month), startOffset=(0.5 * r3 * (a3 - a1))) text = dr.text( "", fill=self.poster.colors["text"], text_anchor="middle", style=month_style, ) text.add(tpath) g.add(text) if text_date in self.poster.tracks_by_date: self._draw_circle_segment( dr, g, self.poster.tracks_by_date[text_date], a1, a2, radius_range, center, ) day += 1 date += datetime.timedelta(1)
def _create_group(self, drawing: Drawing, projection: np.ndarray, viewport: Viewport, group: Group): """ Render all the meshes contained in this group. The main consideration here is that we will consider the z-index of every object in this group. """ default_style = group.style or {} shaders = [ mesh.shader or (lambda face_index, winding: {}) for mesh in group.meshes ] annotators = [ mesh.annotator or (lambda face_index: None) for mesh in group.meshes ] # A combination of mesh and face indes mesh_faces: List[np.ndarray] = [] for i, mesh in enumerate(group.meshes): faces = mesh.faces # Extend each point to a vec4, then transform to clip space. faces = np.dstack([faces, np.ones(faces.shape[:2])]) faces = np.dot(faces, projection) # Reject trivially clipped polygons. xyz, w = faces[:, :, :3], faces[:, :, 3:] accepted = np.logical_and(np.greater(xyz, -w), np.less(xyz, +w)) accepted = np.all(accepted, 2) # vert is accepted if xyz are all inside accepted = np.any(accepted, 1) # face is accepted if any vert is inside degenerate = np.less_equal(w, 0)[:, :, 0] # vert is bad if its w <= 0 degenerate = np.any(degenerate, 1) # face is bad if any of its verts are bad accepted = np.logical_and(accepted, np.logical_not(degenerate)) faces = np.compress(accepted, faces, axis=0) # Apply perspective transformation. xyz, w = faces[:, :, :3], faces[:, :, 3:] faces = xyz / w mesh_faces.append(faces) # Sort faces from back to front. mesh_face_indices = self._sort_back_to_front(mesh_faces) # Apply viewport transform to X and Y. for faces in mesh_faces: faces[:, :, 0:1] = (1.0 + faces[:, :, 0:1]) * viewport.width / 2 faces[:, :, 1:2] = (1.0 - faces[:, :, 1:2]) * viewport.height / 2 faces[:, :, 0:1] += viewport.minx faces[:, :, 1:2] += viewport.miny # Compute the winding direction of each polygon. mesh_windings: List[np.ndarray] = [] for faces in mesh_faces: windings = np.zeros(faces.shape[0]) if faces.shape[1] >= 3: p0, p1, p2 = faces[:, 0, :], faces[:, 1, :], faces[:, 2, :] normals = np.cross(p2 - p0, p1 - p0) np.copyto(windings, normals[:, 2]) mesh_windings.append(windings) group_ = drawing.g(**default_style) text_group_ = drawing.g(**default_style) # Finally draw the group for mesh_index, face_index in mesh_face_indices: face = mesh_faces[mesh_index][face_index] style = shaders[mesh_index](face_index, mesh_windings[mesh_index][face_index]) if style is None: continue face = np.around(face[:, :2], self.precision) if len(face) == 1: group_.add( drawing.circle(face[0], style.pop("radius", 0.005), **style)) if len(face) == 2: group_.add(drawing.line(face[0], face[1], **style)) else: group_.add(drawing.polygon(face, **style)) annotation = annotators[mesh_index](face_index) if annotation is not None: centroid = face.mean(axis=0) text_group_.add(drawing.text(insert=centroid, **annotation)) return [group_, text_group_]