def run_script(args):
matplotlib.interactive(False)
left = (args.left[0], args.left[1])
right = (args.right[0], args.right[1])
l1 = (150,110,110)
l2 = (110,150,110)
l3 = (110,110,150)
layers= [l1,l2]
# This is a hack to conserve colors
colourmap = { rgb(l1[0],l1[1],l1[2]): args.Rock0,
rgb(l2[0],l2[1],l2[2]): args.Rock1 }
if not isinstance(args.Rock2, str):
colourmap[rgb( l3[0],l3[1],l3[2])] = args.Rock2
layers.append( l3 )
model = mb.body( traces = args.ntraces,
pad = args.pad,
margin=args.margin,
left = left,
right = right,
layers = layers
)
return modelr_plot(model, colourmap, args)
def writeShape(shape, params):
if isinstance(shape, list):
for i in shape:
writeShape(i, params)
elif isinstance(shape, tuple):
if len(shape) == 2:
x, y = shape
c = 0
elif len(shape) == 3:
x, y, c = shape
else:
raise Exception('Invalid point {}'.format(shape))
x = (x * params['scale']) + (params['size'] / 2)
y = (-y * params['scale']) + (params['size'] / 2)
c = (c - params['colour_min']) / params['colour_range']
if 0 < x < params['size'] and 0 < y < params['size']:
r, g, b = colorsys.hsv_to_rgb(c, 1, 1)
params['svg'].add(params['svg'].circle(center = (x, y), r = 1, stroke = svgwrite.rgb(r * 255, g * 255, b * 255)))
elif isinstance(shape, data.Line):
for (x1, y1), (x2, y2) in zip(shape.points[:-1], shape.points[1:]):
x1 = (x1 * params['scale']) + (params['size'] / 2)
y1 = (-y1 * params['scale']) + (params['size'] / 2)
x2 = (x2 * params['scale']) + (params['size'] / 2)
y2 = (-y2 * params['scale']) + (params['size'] / 2)
if 0 < x1 < params['size'] and 0 < y1 < params['size'] and 0 < x2 < params['size'] and 0 < y2 < params['size']:
params['svg'].add(params['svg'].line((x1, y1), (x2, y2), stroke = svgwrite.rgb(255, 0, 0)))
else:
print('Cannot plot type', type(shape))
def svg_shape(self):
"""return the SVG shape that this object represents"""
r, g, b = my_colormap[self.label]
x, y, dx, dy = self.get_rect_data()
return svgwrite.shapes.Rect(
insert=(x, y), size=(dx, dy), stroke=svgwrite.rgb(r, g, b, "RGB"), fill=svgwrite.rgb(r, g, b, "RGB")
)
def graphic_output(self):
cell_size = 100
canvas_width = self.grid_width * cell_size
canvas_height = self.grid_height * cell_size
fname = "graph i=" + str(self.number_of_iterations_yet) + " width=" + str(canvas_width) + " height=" +str(canvas_height) + ".svg"
dwg = svgwrite.Drawing(filename = fname, size = (canvas_width, canvas_height), debug = True)
# Draw horizontal grid lines
#for x in range(0, self.grid_width):
# dwg.add( dwg.line((x*cell_size, 0), (x*cell_size, canvas_height), stroke=svgwrite.rgb(0, 0, 0, "%")) )
#for y in range(0, self.grid_height):
# dwg.add( dwg.line((0, y*cell_size), (canvas_width, y*cell_size), stroke=svgwrite.rgb(0, 0, 0, "%")) )
for row in self.grid:
for square in row:
shapes = dwg.add(dwg.g(id='shapes', fill='red'))
color_numerator = float(square.get_utility()) if type(square.get_utility()) is IntType else 0
color_denominator = 2
fill_color = svgwrite.rgb(255, 255, 255)
if color_numerator > 0:
fill_color = svgwrite.rgb(255-250*(color_numerator/color_denominator), 220, 255-200*(color_denominator/color_denominator))
elif color_numerator < 0:
fill_color = svgwrite.rgb(220, 255-250*(abs(color_numerator)/color_denominator), 255-250*(abs(color_numerator)/color_denominator) )
shapes.add( dwg.rect(insert=(square.x*cell_size, square.y*cell_size), size=(cell_size, cell_size), fill=fill_color) )
paragraph = dwg.add(dwg.g(font_size=16))
paragraph.add(dwg.text(square.get_utility(), ( (square.x + 0.5) * cell_size, (square.y + 0.5) * cell_size)))
dwg.save()
print "grid.graphic_output() successful"
return 0
def printmatrixmonthly(m,d): #matrix, drawing x_pos = 0 y_pos = 0 yearnum = 0 for y in m: #for every year in the matrix curmo = 1 weeknum = 0 x_pos = 0 #print(yearnum+startyear) for w in y: #for every week in the year #print(weeknum) if(isnewmonth(yearnum+startyear,weeknum+1,curmo)): x_pos = 0 curmo += 1 y_pos += shape_size + 2 #new month #d.add(d.text(curmo, insert=(x_pos, y_pos), fill='red')) #x_pos += 5 typecount = 0 for t in w: #for every square count in the week n = 0 #count number of squares while n < t: #d.add(d.rect((x_pos, y_pos), (shape_size, shape_size), fill=svgwrite.rgb(worktypes[typecount][1], worktypes[typecount][2], worktypes[typecount][3]))) #print square d.add(d.circle((x_pos, y_pos), shape_size/2, fill=svgwrite.rgb(worktypes[typecount][1], worktypes[typecount][2], worktypes[typecount][3]))) #print circle x_pos += shape_size + 1 n += 1 typecount += 1 weeknum += 1 d.add(d.rect((0, y_pos+1), (6, 4), fill=svgwrite.rgb(0,0,0))) #new year marker y_pos += 6 #new year yearnum += 1 d.save()
def get_reflectivity(data,
colourmap,
theta=0,
reflectivity_method=reflection.zoeppritz
):
'''
Create reflectivities from an image of an earth model and a
mapping of colours to rock properties. Will find each interface
and use the specified reflectivity method to calculate the Vp
reflection coefficient.
:param data: The image data of the earth model. A 3D array indexed
as [samples, traces, colour].
:param colourmap: A lookup table (dict) that maps colour values to
rock property structures.
:keyword theta: Angle of incidence to use reflectivity. Can be a
float or an array of angles [deg].
:keyword reflectivity_method: The reflectivity algorithm to use.
See bruges.reflection for methods.
:returns: The vp reflectivity coefficients corresponding to the
earth model. Data will be indexed as
[sample, trace, theta]
'''
# Check if we only have one trace of data, and reform the array
if(data.ndim == 2):
reflect_data = np.zeros((data.size, 1, np.size(theta)))
data = np.reshape(data, (data.shape[0], 1, 3))
else:
reflect_data = np.zeros((data.shape[0], data.shape[1],
np.size(theta)))
# Make an array that only has the boundaries in it
boundaries = get_boundaries(data)
for i in boundaries:
# These are the indices in data
j = i.copy()
j[0] += 1
# Get the colourmap dictionary keys
c1 = rgb(data[i[0], i[1], 0], data[i[0], i[1], 1],
data[i[0], i[1], 2])
c2 = rgb(data[j[0], j[1], 0], data[j[0], j[1], 1],
data[j[0], j[1], 2])
# Don't calculate if not in the cmap. If the model was
# build properly this shouldn't happen.
if((c1 not in colourmap) or (c2 not in colourmap)):
continue
# Get the reflectivity
reflect_data[i[0], i[1], :] = rock_reflectivity(
colourmap[c1], colourmap[c2], theta=theta,
method=reflectivity_method)
return reflect_data
def visualize_graph(graph, graph_parameters, output_file = None): if not graph_parameters.is_correct: raise Exception() #!!!!! graph_utilities = GraphUtilities(graph_parameters) drawing = svgwrite.Drawing() for node in graph_utilities.nodes(graph): node_view_points = \ [(node_vertex.real * 1, - node_vertex.imag * 1) for node_vertex \ in graph_utilities.compute_node_vertices(node)] node_view = \ svgwrite.shapes.Polygon( node_view_points, fill = svgwrite.rgb(0, 0, 0), fill_opacity = 1.0, stroke = svgwrite.rgb(0, 0, 0), stroke_width = 0.1, stroke_opacity = 1.0 ) drawing.add(node_view) if output_file is not None: drawing.write(output_file) else: return drawing
def run_script(args):
matplotlib.interactive(False)
"""if args.transparent == 'False' or args.transparent == 'No':
transparent = False
else:
transparent = True"""
args.ntraces = 300
args.pad = 150
args.reflectivity_method = zoeppritz
args.title = "Channel - angle gather (AVA)"
args.theta = (0, 50, 0.5)
args.wavelet = ricker
args.wiggle_skips = 10
args.aspect_ratio = 1
args.thickness = 50
args.margin = 1
args.slice = "angle"
transparent = False
# This is a hack to conserve colors
l1 = (150, 110, 110)
l2 = (110, 150, 110)
l3 = (110, 110, 150)
layers = [l1, l2]
colourmap = {rgb(150, 110, 110): args.Rock0, rgb(110, 150, 110): args.Rock1}
if not isinstance(args.Rock2, str):
colourmap[rgb(110, 110, 150)] = args.Rock2
layers.append(l3)
# Get the physical model (an array of rocks)
model = mb.channel(pad=args.pad, thickness=args.thickness, traces=args.ntraces, layers=layers)
return modelr_plot(model, colourmap, args)
def svg_shape(self):
"""return the SVG shape that this object represents"""
r, g, b = my_colormap[self.label]
return svgwrite.shapes.Circle(
center=(self.shape.x, self.shape.y),
r=self.shape.radius,
stroke=svgwrite.rgb(r, g, b, "RGB"),
fill=svgwrite.rgb(r, g, b, "RGB"),
)
def getline(startcoord):
startcoord = startcoord
endcoord = calculateEndCoord(startcoord)
dwg.add(dwg.circle(startcoord, 2.5, stroke=svgwrite.rgb(10, 10, 16, '%'), fill='white'))
for i in range(50):
dwg.add(dwg.line(startcoord, endcoord, stroke=svgwrite.rgb(10, 10, 16, '%')))
startcoord = endcoord
endcoord = calculateEndCoord(startcoord)
dwg.add(dwg.circle(startcoord, 2.5, stroke=svgwrite.rgb(10, 10, 16, '%'),fill='white'))
def draw_grid(self):
for i, n in enumerate(range(self.offset, self.width + 1, self.square_size)):
self._draw_square(i, i, self.nodes[i - 1], fill='gray')
self.dwg.add(self.dwg.line((self.offset, n),
(self.width, n),
stroke_width=self.line_width,
stroke=svgwrite.rgb(10, 10, 16, '%')))
self.dwg.add(self.dwg.line((n, self.offset),
(n, self.height),
stroke_width=self.line_width,
stroke=svgwrite.rgb(10, 10, 16, '%')))
def plotfaces():
for i in range(-N,N):
for j in range(-N,N):
if(i+j+1 <= N and i+j >= -N):
stroke=svgwrite.rgb(10, 10, 16, '%')
dwg.add(dwg.polygon(points=[coords(i+1,j),coords(i,j+1),coords(i,j)],fill='blue'))
for i in range(-N,N):
for j in range(-N,N):
if(i+j+2 <= N and i+j+1 >= -N):
stroke=svgwrite.rgb(10, 10, 16, '%')
dwg.add(dwg.polygon(points=[coords(i+1,j),coords(i,j+1),coords(i+1,j+1)],fill='red'))
def zadani3_B_c():
polomer = 100
krok = 9
dwg = svgwrite.Drawing("results/kulata_mriz.svg")
offset = polomer
for i in range(krok/2, polomer+1, krok):
x = i
y = (polomer**2 - x ** 2) ** 0.5
dwg.add(dwg.line((x + offset, y + offset), (x + offset, -y + offset), stroke=svgwrite.rgb(10, 10, 16, '%')))
dwg.add(dwg.line((-x + offset, y + offset), (-x + offset, -y + offset), stroke=svgwrite.rgb(10, 10, 16, '%')))
dwg.add(dwg.line((-y + offset, x + offset), (y + offset, x + offset), stroke=svgwrite.rgb(10, 10, 16, '%')))
dwg.add(dwg.line((-y + offset, -x + offset), (y + offset, -x + offset), stroke=svgwrite.rgb(10, 10, 16, '%')))
dwg.save()
def channel_svg(pad, thickness, traces, layers):
"""
Makes a rounded channel.
Give it pad, thickness, traces, and an iterable of layers.
Returns an SVG file.
:param pad: The number (n) of points on top of the channel.
:param: thickness: The radius of the channel (npoints).
:param traces: The number of traces in the channel model.
:param layers: An 3X3 array or tuple of RGB values corresponding
to each rock layer. ((R,G,B),(R,G,B),(R,G,B)).
Indexed as (top, channel, bottom ).
:returns: a tempfile object pointed to the model svg file.
"""
outfile = tempfile.NamedTemporaryFile(suffix='.svg', delete=True )
top_colour = rgb( layers[0][0],layers[0][1], layers[0][2] )
body_colour = rgb( layers[1][0],layers[1][1], layers[1][2] )
bottom_colour = rgb( layers[2][0],layers[2][1], layers[2][2] )
width = traces
height = 2.5*pad + thickness
dwg = svgwrite.Drawing(outfile.name, size=(width,height),
profile='tiny')
# Draw the bottom layer
bottom_layer = \
svgwrite.shapes.Rect(insert=(0,0),
size=(width,height)).fill(bottom_colour)
dwg.add(bottom_layer)
# Draw the body
body = \
svgwrite.shapes.Ellipse(center=(width/2,pad/2),
r=(0.3*width,pad+thickness)).fill(body_colour)
dwg.add(body)
# Draw the top layer
top_layer = \
svgwrite.shapes.Rect(insert=(0,0),
size=(width,pad)).fill(top_colour)
dwg.add(top_layer)
# Do this for a file
dwg.save()
return outfile
def recur_triangle():
verts = ngram_vertexes(3, 400)
triang = Polygon(verts)
dwg = svgwrite.Drawing('triang.svg')
offset = 0
dwg.add(dwg.circle((verts[0][0] + offset, verts[0][1] + offset), r=1, stroke=svgwrite.rgb(255, 0, 0, '%')))
dwg.add(dwg.circle((verts[1][0] + offset, verts[1][1] + offset), r=1, stroke=svgwrite.rgb(255, 0, 0, '%')))
dwg.add(dwg.circle((verts[2][0] + offset, verts[2][1] + offset), r=1, stroke=svgwrite.rgb(255, 0, 0, '%')))
recurse_transformations(triang, dwg, 7, 100)
dwg.save()
def use(name):
# Shows how to use the 'use' element.
#
w, h = '100%', '100%'
dwg = svgwrite.Drawing(filename=name, size=(w, h), debug=True)
dwg.add(dwg.rect(insert=(0,0), size=(w, h), fill='lightgray', stroke='black'))
# add a group of graphic elements to the defs section of the main drawing
g = dwg.defs.add(dwg.g(id='g001'))
unit=40
g.add(dwg.rect((0,0), (unit, unit)))
for y in range(10):
for x in range(5):
x1 = 2*unit+2*unit*x
y1 = 2*unit+2*unit*y
cx = x1 + unit/2
cy = y1 + unit/2
cval = (y*5 + x)*2
# reference the group by the 'use' element, you can overwrite
# graphical properties, ...
u = dwg.use(g, insert=(x1, y1), fill=rgb(cval, cval, cval))
# ... and you can also transform the the whole reference object.
u.rotate(y*5+x, center=(cx, cy))
dwg.add(u)
dwg.save()
def mandala(filename='poirot.svg'):
'''
Draw a mandala, inspired by Danna's.
'''
d = svgwrite.Drawing(filename)
d.add(d.line((0, 0), (10, 0), stroke=svgwrite.rgb(10, 10, 16, '%')))
d.save()
def renderSegments(svg, segments, offset, scale): for segment in segments: svg.add(svg.line( mult(add(segment[0], offset), scale), mult(add(segment[1], offset), scale), stroke=svgwrite.rgb(0, 0, 0, '%'), stroke_width=2, stroke_linecap="square"))
def print_path(path):
print(path)
wall=50
for l in range(1, len(path)+1):
dwg = svgwrite.Drawing('color_maze_solution' + str(l)+ '.svg', profile='full')
dwg.add(dwg.line((0, 0), (0, size_X * wall), stroke=svgwrite.rgb(0, 0, 0, '%')))
dwg.add(dwg.line((0, 0), (size_X * wall, 0), stroke=svgwrite.rgb(0, 0, 0, '%')))
dwg.add(dwg.line((size_X * wall, size_X * wall), (size_X * wall, 0), stroke=svgwrite.rgb(0, 0, 0, '%')))
dwg.add(dwg.line((size_X * wall, size_X * wall), (0, size_X * wall), stroke=svgwrite.rgb(0, 0, 0, '%')))
for x in range(l):
i=path[x][0]
j=path[x][1]
dwg.add(dwg.rect((j * 50, i * 50), (50, 50), fill=dict[maze[i][j]]))
dwg.add(dwg.text("start",(10,(size_X-1)*50+25)))
dwg.save()
def displaySVGPaths(pathList,*colors): #creates and saves an svf file displaying the input paths
show_closed_discont=True
import svgwrite
from svgpathtools import Path, Line, CubicBezier
# from time import strftime
# from re import sub
# dwg = svgwrite.Drawing('temporary_displaySVGPaths%s.svg'%time_date, size= ("%spx"%(int(xmax-xmin+1)), "%spx"%(int(ymax-ymin+1))))
# dwg = svgwrite.Drawing('temporary_displaySVGPaths%s.svg'%time_date)
dwg = svgwrite.Drawing('temporary_displaySVGPaths.svg')
dwg.add(dwg.rect(insert=(0, 0), size=('100%', '100%'), rx=None, ry=None, fill='white')) #add white background
dc = 100/len(pathList)
for i,p in enumerate(pathList):
if isinstance(p,Path):
startpt = p[0].start
ps = path2str(p)
elif isinstance(p,Line) or isinstance(p,CubicBezier):
startpt = p.start
ps = path2str(p)
else:
startpt = parse_path(p)[0].start
ps = p
if colors !=tuple():
dwg.add(dwg.path(ps, stroke=colors[0][i], fill='none'))
else:
dwg.add(dwg.path(ps, stroke=svgwrite.rgb(0+dc, 0+dc, 16, '%'), fill='none'))
if show_closed_discont and isApproxClosedPath(p):
startpt = (startpt.real,startpt.imag)
dwg.add(dwg.circle(startpt,1, stroke='gray', fill='gray'))
dwg.save()
def printmatrix(m,d): x_pos = 0 y_pos = 0 yearnum = 0 for y in m: #for every year in the matrix curmo = 1 weeknum = 0 for w in y: #for every week in the year x_pos = 0 if(isnewmonth(yearnum+startyear,weeknum+1,curmo)): curmo += 1 y_pos += shape_size + 2 #new month else: y_pos += shape_size + 1 #new week typecount = 0 for t in w: #for every square count in the week n = 0 #count number of squares while n < t: #d.add(d.rect((x_pos, y_pos), (shape_size, shape_size), fill=svgwrite.rgb(worktypes[typecount][1], worktypes[typecount][2], worktypes[typecount][3]))) #print square d.add(d.circle((x_pos, y_pos), shape_size/2, fill=svgwrite.rgb(worktypes[typecount][1], worktypes[typecount][2], worktypes[typecount][3]))) #print circle x_pos += shape_size + 1 n += 1 typecount += 1 weeknum += 1 y_pos += 6 #new year yearnum += 1 d.save()
def ex1(name):
stvorec = square(200)
pocet_opakovani = 120
translist = []
translist.append(shear(0.1))
translist.append(rotate(radians(7)))
name = "pokus4"
img = svgwrite.Drawing('transformations_' + name + '.svg', profile='tiny')
stroke = svgwrite.rgb(10,10,16,'%')
size = 1000
for i in range(pocet_opakovani):
lines = []
for bod in stvorec:
lines.append(np.dot(trans(translist),[bod[0],bod[1],1]))
#vykresleni jednu transformaciu
for idx,bod in enumerate(lines):
bod2 = lines[(idx+1)%len(lines)]
fr = ( int(bod[0]+size/2), int(bod[1])+size/2 )
to = ( int(bod2[0]+size/2), int(bod2[1])+size/2 )
img.add(img.line(fr, to, stroke=stroke))
stvorec = lines
img.save()
def convert(input,output,width,height,scale):
d = xml.etree.ElementTree.parse(input)
r = d.getroot()
scale = int(scale)
width = int(width)
height = int(height)
canvas = svg.Drawing(output, size=(str(width*scale), str(height*scale)))
canvas.add(canvas.rect(insert=(0, 0), size=('100%', '100%'), rx=None, ry=None, fill='rgb(0,0,0)'))
for poly in r.find('Polygons'):
red = int(poly.find('Brush').find('Red').text)
blue = int(poly.find('Brush').find('Blue').text)
green = int(poly.find('Brush').find('Green').text)
alpha = float(poly.find('Brush').find('Alpha').text)
alpha = alpha/255
color = svg.rgb(red,green,blue)
pts = []
for point in poly.find('Points'):
x = int(point.find('X').text)*scale
y = int(point.find('Y').text)*scale
pts.append((x,y))
canvas.add(svg.shapes.Polygon(points=pts, fill=color, opacity=alpha))
canvas.save()
def draw(): drawing = Drawing(drawing_file_name, drawing_size) first_circle_view = \ Circle( center = first_circle_center, r = first_circle_radius, fill_opacity = 0, stroke = rgb(0, 0, 0), stroke_width = 1 ) first_circle_center_view = \ Circle( center = first_circle_center, r = 3, fill = rgb(0, 0, 0), stroke_width = 0 ) drawing.add(first_circle_view) drawing.add(first_circle_center_view) second_circle_view = \ Circle( center = second_circle_center, r = second_circle_radius, fill_opacity = 0, stroke = rgb(0, 0, 0), stroke_width = 1 ) second_circle_center_view = \ Circle( center = second_circle_center, r = 3, fill = rgb(0, 0, 0), stroke_width = 0 ) drawing.add(second_circle_view) drawing.add(second_circle_center_view) drawing.save()
def generate_image(lines):
dwg = svgwrite.Drawing('out.svg', profile='tiny')
for line in lines:
(r, g, b) = (10, 10, 16) if len(line) < 3 else line[2]
width = 1 if len(line) < 4 else line[3]
dwg.add(dwg.line(line[0], line[1], stroke=svgwrite.rgb(r, g, b, '%'), stroke_width = width))
#dwg.add(dwg.text('Test', insert=(0, 0.2), fill='red'))
dwg.save()
def test_svgwrite_line():
dwg = svgwrite.Drawing(svg_filename, profile='tiny')
stroke = svgwrite.rgb(10, 10, 16, '%')
line = svgwrite.shapes.Line((0, 0), (10, 0), stroke=stroke)
text = dwg.text('Test', insert=(0, 0.2), fill='red')
dwg.add(line)
dwg.add(text)
dwg.save()
def __init__(self, dates, rgb_color, name):
self.start_date = dates[0]
self.end_date = dates[1]
self.dates = dates
self._rgb_color = rgb_color
self.background_color = svgwrite.rgb(*rgb_color)
self.name = name
self.slot = None
def initDraw(name,dimX,dimY): """ A function which oppen a new draw, called "name", and write a white rectangle of drawingDimension*drawingDimension """ dwg = svgwrite.Drawing(name,size=(dimX,dimY), profile='full') dwg.add(dwg.rect((0,0),(dimX,dimY),fill=svgwrite.rgb(255,255,255))) return dwg
def drawExon(dwg,lineNumber,start,end,rvb,idExon):
"""
A function which draw a new exon on a opened dwg draw
it draw that exon from 'start', to 'end' (x position)
at the line 'lineNumber' (y position) with the color
'rvb'
"""
dwg.add(dwg.rect((start,lineNumber),(end - start, exon_height),fill=svgwrite.rgb(rvb[0],rvb[1],rvb[2]),id="exon",onmouseover="evt.target.setAttribute('opacity', '0.5');",onmouseout="evt.target.setAttribute('opacity','1)');"))
def image_svg(self, svg, scale, stonescale=1.0):
"""Draw the map to an svg image."""
import svgwrite
dwg = svg
log.debug('Creating map image svg')
dwg.add(dwg.line((0, 0), (10, 0), stroke=svgwrite.rgb(10, 10, 16, '%')))
dwg.add(dwg.text('Test', insert=(0, 0.2), fill='red'))
for s in self.stones:
center, size, angle = s.center, s.size, s.angle
center = float((self.size[0] - center[0]) / scale), float(center[1] / scale)
size = float(size[0] / scale) * stonescale, float(size[1] / scale) * stonescale
dummy = np.array([np.array([s.color], dtype=np.uint8)])
color = (cv2.cvtColor(dummy, cv2.COLOR_LAB2BGR)[0, 0]).tolist()
svgcolor = svgwrite.rgb(color[2], color[1], color[0], 'RGB')
# structure = s.structure
# cv2.ellipse(img, center, size, 360 - angle, 0, 360, color, -1)
svg_ellip = dwg.ellipse(center=center, r=size, fill=svgcolor)
svg_ellip.rotate(360 - angle, center=center)
dwg.add(svg_ellip)
cl = 2.0
svg_line1 = dwg.line(start=(center[0] + cl, center[1]), end=(center[0] - cl, center[1]), stroke='red')
svg_line1.rotate(360 - angle, center=center)
dwg.add(svg_line1)
svg_line2 = dwg.line(start=(center[0], center[1] + cl), end=(center[0], center[1] - cl), stroke='red')
svg_line2.rotate(360 - angle, center=center)
dwg.add(svg_line2)
# if s.flag:
# cv2.circle(img, center, 3, (0, 69, 255))
for h in self.holes:
center = float((self.size[0] - h.center[0]) / scale), float(h.center[1] / scale)
size = float(h.size / scale)
print size
print center
svg_circle = dwg.circle(center=center, r=size, stroke='black', stroke_width=0.8, fill='none')
dwg.add(svg_circle)
def run_script(args):
matplotlib.interactive(False)
"""if args.transparent == 'False' or args.transparent == 'No':
transparent = False
else:
transparent = True"""
args.ntraces = 300
args.pad = 150
args.reflectivity_method = zoeppritz
args.title = 'Wedge model - wavelet cross section'
args.wavelet = ricker
args.wiggle_skips = 10
args.aspect_ratio = 1
args.left = (0, 0)
args.right = (0, 50)
args.margin = 1
args.slice = 'frequency'
args.f = (8, 256, 1)
transparent = False
# This is a hack to conserve colors
l1 = (150, 110, 110)
l2 = (110, 150, 110)
l3 = (110, 110, 150)
layers = [l1, l2]
colourmap = {
rgb(150, 110, 110): args.Rock0,
rgb(110, 150, 110): args.Rock1
}
if not isinstance(args.Rock2, str):
colourmap[rgb(110, 110, 150)] = args.Rock2
layers.append(l3)
# Get the physical model (an array of rocks)
model = mb.body(traces=args.ntraces,
pad=args.pad,
margin=args.margin,
left=args.left,
right=args.right,
layers=layers)
return modelr_plot(model, colourmap, args)
def plot_grid():
# horizontal lines
for col in range(1, len(columns)):
for row in range(0, len(rows)):
x1, y1 = coord(col - 1, row)
x2, y2 = coord(col, row)
dwg.add(
dwg.line((x1 + 5, y1), (x2 - 5, y2),
stroke=svgwrite.rgb(10, 10, 16,
'%'))).dasharray([5, 5])
for col in range(0, len(columns)):
for row in range(1, len(rows)):
x1, y1 = coord(col, row - 1)
x2, y2 = coord(col, row)
dwg.add(
dwg.line((x1, y1 + 5), (x2, y2 - 5),
stroke=svgwrite.rgb(10, 10, 16,
'%'))).dasharray([5, 5])
def write_svg(fn, vertices, edges):
import svgwrite
dwg = svgwrite.Drawing(fn+'.svg', profile='tiny')
for a, b in edges:
p1 = get_coord(vertices, a, scale=1000.0)
p2 = get_coord(vertices, b, scale=1000.0)
dwg.add(dwg.line(p1, p2, stroke=svgwrite.rgb(10, 10, 16, '%')))
dwg.save()
def showCell(dwg, grid, cell, cell_size, center):
radius = (cell.row + .5) * cell_size
theta = 2 * math.pi / len(grid[cell.row])
angle = (cell.column + .5) * theta
coords = polarToRect(center, radius, angle)
dwg.add(
dwg.circle(center=(coords.x, coords.y),
r=(cell_size * .25),
stroke=svgwrite.rgb(10, 10, 16, '%'),
fill='red'))
def render(lines, points):
img = svgwrite.Drawing('intersections.svg', profile='tiny')
stroke = svgwrite.rgb(10, 10, 16, '%')
for f, t in lines:
img.add(img.line(f, t, stroke=stroke))
for p in points:
img.add(img.circle(p, r=3))
img.save()
def thingy(d):
paper_centre = Point(102.5, 148)
paper_size = Point(192, 270)
lines = []
lines_r = []
lines_g = []
lines_b = []
size = 3
nr = 50
nc = 30
for r in range(0, nr+1):
for c in range(0, nc+1):
pt = paper_centre + Point(0, 5) * (r - nr/2) + Point(5, 0) * (c - nc/2)
a = random.random() * math.pi * 2
line = d.make_square(pt, size)
line.append(line[0])
centre = pt + Point(1,1) * size/2
line = [d.rotate_about(pt, centre, a) for pt in line]
lines.append(line)
line = d.make_circle(centre, size/4)
lines_circle = lines_b
x = random.random()
if x < 0.333:
lines_circle = lines_r
elif x < 0.666:
lines_circle = lines_g
lines_circle.append(line)
line = d.make_square(pt + Point(1,1)*size/4, size/2)
line.append(line[0])
centre = pt + Point(1,1) * size/2
line = [d.rotate_about(pt, centre, a) for pt in line]
# lines.append(line)
d.add_polylines(lines, container=d.add_layer("1"))
d.add_polylines(lines_r, container=d.add_layer("2"), stroke=svgwrite.rgb(100, 0, 0, '%'))
d.add_polylines(lines_g, container=d.add_layer("3"), stroke=svgwrite.rgb(0, 50, 0, '%'))
d.add_polylines(lines_b, container=d.add_layer("4"), stroke=svgwrite.rgb(0, 0, 100, '%'))
def save(self):
dwg = svgwrite.Drawing(self.output_filename, profile="full")
shapes = self.get_current_shapes()
for shape in shapes:
shape_type = shape["type"]
if shape_type == "line":
# color 0 - 1.0 -> percentage
color = tuple(map(lambda x: min(x * 100, 100), shape["color"]))
pline = dwg.polyline(
points=shape["points"],
stroke=svgwrite.rgb(color[0], color[1], color[2], "%"),
stroke_width=shape["width"],
fill_opacity=0,
)
dwg.add(pline)
elif shape_type == "text":
text = shape["text"]
color = tuple(map(lambda x: min(x * 100, 100), shape["color"]))
dwg.add(
dwg.text(
text,
font_size=self.font_size,
font_family=FONT_NAME,
insert=shape["position"],
stroke=svgwrite.rgb(*color, "%"),
)
)
elif shape_type == "rect":
width = shape["width"]
height = shape["height"]
color = tuple(map(lambda x: min(x * 100, 100), shape["color"]))
position = shape["position"]
dwg.add(
dwg.rect(
insert=position,
size=(width, height),
fill=svgwrite.rgb(*color, "%"),
)
)
# elif shape_type == "image":
dwg.save()
def render_features_from_text(input_text: str):
global parser
try:
expression: MathExpression = parser.parse(input_text)
state = MathyEnvState(problem=input_text)
observation: MathyObservation = state.to_observation(
hash_type=[13, 37])
length = len(observation.nodes)
types = observation.nodes
values = observation.values
nodes = expression.to_list()
chars = [n.name for n in nodes]
assert len(types) == len(values) == len(chars)
view_x = 0
view_y = 0
view_w = BOX_SIZE * length
view_h = BOX_SIZE * 3 + BORDER_WIDTH * 2
tree = svgwrite.Drawing(size=(view_w, view_h))
tree.viewbox(minx=view_x, miny=view_y, width=view_w, height=view_h)
curr_x = BORDER_WIDTH
for n, t, v, c in zip(nodes, types, values, chars):
color = svgwrite.rgb(180, 200, 255)
if isinstance(n, BinaryExpression):
color = svgwrite.rgb(230, 230, 230)
elif isinstance(n, VariableExpression):
color = svgwrite.rgb(150, 250, 150)
if n == n.get_root():
color = svgwrite.rgb(250, 220, 200)
box_with_char(tree, c, x=curr_x, y=BORDER_WIDTH, fill=color)
box_with_char(tree, v, x=curr_x, y=BOX_SIZE + BORDER_WIDTH)
box_with_char(tree, t, x=curr_x, y=BOX_SIZE * 2 + BORDER_WIDTH)
curr_x += BOX_SIZE - (BORDER_WIDTH)
return svgwrite.utils.pretty_xml(tree.tostring(), indent=2)
except BaseException as error:
return f"Failed to parse: '{input_text}' with error: {error}"
def run_script(args):
matplotlib.interactive(False)
Rprop0 = args.Rock0
Rprop1 = args.Rock1
Rprop2 = args.Rock2
Rprop3 = args.Rock3
colourmap = {}
if isinstance(Rprop0, str):
Rprop0 = None
else:
colourmap[rgb(255,255,255)] = Rprop0
if isinstance(Rprop1, str):
Rprop1 = None
else:
colourmap[rgb( 255,0,0 )] = Rprop1
if isinstance(Rprop2, str):
Rprop2 = None
else:
colourmap[rgb( 0,0,255 )] = Rprop2
if isinstance(Rprop3, str):
Rprop3 = None
else:
colourmap[3] = Rprop3
if not isinstance(args.rocks, int):
colours = 0
else:
colours = args.rocks
colours = ((255,255,255),(255,0,0), (0,0,255) )
model = mb.web2array(args.url,
colours = colours
)
return modelr_plot( model, colourmap, args )
def DrawDefaultStatusBox(self):
self.dwg.add(
self.dwg.use(self.device_not,
x=self.ConBoxMargin + (self.CntBoxWidth * 0.5) +
self.grid_s * 0.5,
y=self.top_m + 20))
self.dwg.add(
self.dwg.text("NOT Gate",
x=[self.ConBoxMargin + (self.CntBoxWidth * 0.5)],
y=[self.top_m + 60],
text_anchor="middle",
alignment_baseline="central",
font_size="%dpt" % int(self.grid_s * 0.20),
font_family="consolas"))
self.dwg.add(
self.dwg.text("NOR Gate",
x=[self.ConBoxMargin + (self.CntBoxWidth * 0.5)],
y=[self.top_m + 170],
text_anchor="middle",
alignment_baseline="central",
font_size="%dpt" % int(self.grid_s * 0.20),
font_family="consolas"))
self.dwg.add(
self.dwg.use(self.device_nor,
x=self.ConBoxMargin + (self.CntBoxWidth * 0.5) +
self.grid_s * 0.5,
y=self.top_m + 120))
self.dwg.add(
self.dwg.rect((self.ConBoxMargin, self.top_m * 2),
(self.CntBoxWidth, 80),
rx=10,
ry=10,
fill=svgwrite.rgb(100, 100, 100, '%'),
stroke=svgwrite.rgb(0, 0, 0, '%')))
self.dwg.add(
self.dwg.text("Current Inst",
x=[self.ConBoxMargin + (self.CntBoxWidth * 0.5)],
y=[self.top_m * 2.7],
text_anchor="middle",
alignment_baseline="central",
font_size="%dpt" % int(self.grid_s * 0.30),
font_family="consolas"))
def render_connectivity_graph(self, ):
for i, room in enumerate(self.floorplan.rooms):
for e in room.edges:
for door in e.doors:
self.group.add(
self.drawing.line(
self.scale_point(room.center),
self.scale_point(e.center), **{
"stroke": svgwrite.rgb(0, 255, 0),
"stroke-width": 4
}))
def border(dwg, radius, origin_x, origin_y):
STEPS = 360
points = []
for i in range(STEPS):
theta = i * (pi * 2.0) / STEPS
r1 = radius + (10 * sin(7 * radians(i)))
y1 = r1 * sin(theta) + origin_y
x1 = r1 * cos(theta) + origin_x
points.append((x1, y1))
dwg.add(dwg.polygon(points, fill='none', stroke=svgwrite.rgb(0, 0, 0, '%')))
def main():
n = int(input("Input iteration value: "))
koch_curve(size, n)
dwg = svgwrite.Drawing('koch.svg', profile='tiny')
for i in range(len(points) - 1):
a, b = points[i], points[i + 1]
a[1] += 100
b[1] += 100
dwg.add(dwg.line(a, b, stroke=svgwrite.rgb(0, 0, 0, '%')))
dwg.save()
def __init__(self, dim=None):
if dim is None:
self.dim = self.defaults['dim']
else:
self.dim = dim # list, dimensions, in pixels, [width, height]
self.data = {
} # dictionary to store all data values. will be referenced by data name
self.drawables = OrderedDict(
) # keep track of the drawable items (charts, axes) in the figure. each drawable has a name
self.background_color = rgb(255, 255, 255)
self.anti_aliasing = True
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 get_paletton(filename):
# extract a list of svgwrite colors from a paletton txt file
lines = [
line.split("=") for line in open(filename, "r").readlines()
if len(line.split("=")) > 3
]
rgbs = [
line[2].replace("rgb(", "").replace(")", "").split(",")
for line in lines
]
return [rgb(*[float(x) for x in _rgb]) for _rgb in rgbs]
def curve_to_svg(curve, svg, scale):
domain = curve.Domain
for i in range(100):
t0 = domain.T0 + (domain.T1 - domain.T0) * (i / 100.0)
t1 = domain.T0 + (domain.T1 - domain.T0) * ((i + 1) / 100.0)
pt0 = curve.PointAt(t0)
pt1 = curve.PointAt(t1)
svg.add(
svg.line((pt0.X * scale, pt0.Y * scale),
(pt1.X * scale, pt1.Y * scale),
stroke=svgwrite.rgb(10, 10, 16, '%')))
def draw_grids(dwg, grid, position, show_lines=True):
if len(grid.subgrids) == 0:
grid.shape.draw(dwg, position)
return
x1, y1, x2, y2 = position
up = ((x1 + x2) / 2, y1)
right = (x2, (y1 + y2) / 2)
down = ((x1 + x2) / 2, y2)
left = (x1, (y1 + y2) / 2)
center = ((x1 + x2) / 2, (y1 + y2) / 2)
if show_lines:
dwg.add(dwg.line(up, down, stroke=svgwrite.rgb(10, 10, 16, '%')))
dwg.add(dwg.line(left, right, stroke=svgwrite.rgb(10, 10, 16, '%')))
draw_grids(dwg, grid.subgrids[0], (x1, y1) + center, show_lines)
draw_grids(dwg, grid.subgrids[1], up + right, show_lines)
draw_grids(dwg, grid.subgrids[2], center + (x2, y2), show_lines)
draw_grids(dwg, grid.subgrids[3], left + down, show_lines)
def spirograph6(drawing):
paper_centre = Point(102.5, 148)
r = [70, 3, 2, 1]
s = [1, -1, 1, -1]
scale = 1
for i in range(0, 20):
add_spirograph(drawing,
paper_centre,
r,
s,
scale=scale,
stroke=svgwrite.rgb(0, 0, 0, '%'),
container=drawing.add_layer("1"))
scale *= 0.9
drawing.add_dot(paper_centre,
75,
r_start=73,
stroke=svgwrite.rgb(50, 0, 0, '%'),
container=drawing.add_layer("2"))
def get_poly_kwargs_from_style_obj(style_obj):
return_obj = {}
for k, v in style_obj.items():
#FIXME: This is a really hacky way to extract and convert rgb objects
if type(v) == list:
return_obj[k] = svgwrite.rgb(v[0], v[1], v[2])
else:
return_obj[k] = v
return return_obj
def test_get_reflectivity(self):
cmap = {rgb(150, 100, 100): self.Rp0, rgb(100, 150, 100): self.Rp1}
theta = 15.0
data = np.zeros((100, 100, 3))
data[:50, :, :] += [150, 100, 100]
data[50:, :, :] += [100, 150, 100]
reflectivity = \
get_reflectivity( data, cmap, theta,
reflectivity_method=avo.zoeppritz )
truth = avo.zoeppritz(self.vp0, self.vs0, self.rho0, self.vp1,
self.vs1, self.rho1, theta)
test = np.zeros((100, 100, 1))
test[49, :, 0] = truth
self.assertTrue(np.array_equal(test, reflectivity))
def makelabels(x, y, size, text):
x = x * scale
y = y * scale
dwg.add(
dwg.text(text,
insert=(x, y),
stroke='none',
fill=svgwrite.rgb(15, 15, 15),
font_size=size,
font_weight="bold",
style="font-family:Arial"))
def makesquares(x1, y1, x2, y2):
# draw a nofill box
x1 = x1 * scale
y1 = y1 * scale
x2 = x2 * scale
y2 = y2 * scale
dwg.add(
dwg.rect((x1, y1), (x2, y2),
stroke=svgwrite.rgb(10, 10, 20),
stroke_width=stroke,
fill='none'))
def main():
drawing = svgwrite.Drawing(filename='tower.svg',
size=(page_width, page_height))
drawing.add(
drawing.circle((100 * mm, 100 * mm),
r=30 * mm,
stroke=svgwrite.rgb(255, 255, 255, '%'),
stroke_width=1 * mm))
drawing.add(
drawing.circle((100 * mm, 70 * mm),
r=15 * mm,
stroke=svgwrite.rgb(255, 255, 255, '%'),
stroke_width=1 * mm))
drawing.add(
drawing.circle((100 * mm, 45 * mm),
r=7.5 * mm,
stroke=svgwrite.rgb(255, 255, 255, '%'),
stroke_width=1 * mm))
drawing.save()
def markup_extra_staffs(staff_prop: StaffProperties, staff_start_position,
horizontal_note_position, note_vertical_offset):
objects = []
if note_vertical_offset < 0:
count = abs(int(
(note_vertical_offset) // staff_prop.staff_line_offset))
for idx in range(1, count + 1):
y = staff_start_position - idx * staff_prop.staff_line_offset
line = Polyline(points=[(horizontal_note_position - 40,
y), (horizontal_note_position + 50,
y)]).stroke(
color=svgwrite.rgb(0, 0, 0),
width=2,
linejoin='bevel',
)
# 7 lines in LINE_SET_SETUP, last - bottom.
# Get for next top last with skipping 1 doubled starting and 1 existing.
if LINE_SET_SETUP[-((idx) % 3) - 1]:
line.dasharray([5, 7])
objects += [line]
if note_vertical_offset > staff_prop.staff_height:
count = int((note_vertical_offset - staff_prop.staff_height) //
staff_prop.staff_line_offset)
for idx in range(1, count + 1):
y = staff_start_position + staff_prop.staff_height + idx * staff_prop.staff_line_offset
line = Polyline(points=[(horizontal_note_position - 40,
y), (horizontal_note_position + 50,
y)]).stroke(
color=svgwrite.rgb(0, 0, 0),
width=2,
linejoin='bevel',
)
# 7 lines in LINE_SET_SETUP, first - top. Get for next bottom from start, skipping 1 existing.
if LINE_SET_SETUP[idx % 3]:
line.dasharray([5, 7])
objects += [line]
return objects
def add_boxes(self, step_dict, width, name_fill):
x, y = step_dict['position']['left'], step_dict['position']['top']
self.boxes.append(
svgwrite.shapes.Rect((x - MARGIN, y), (width, 30),
fill=name_fill,
stroke='#000000'))
box_height = (len(step_dict['data_inputs']) +
len(step_dict['data_outputs'])) * LINE_SPACING + MARGIN
# Draw separator line.
if len(step_dict['data_inputs']) > 0:
box_height += LINE_SPACING
sep_y = y + len(step_dict['data_inputs']) * LINE_SPACING + 40
self.text.append(
svgwrite.shapes.Line((x - MARGIN, sep_y),
(x + width - MARGIN, sep_y),
stroke=svgwrite.rgb(0, 0, 0)))
# Define an input/output box.
self.boxes.append(
svgwrite.shapes.Rect((x - MARGIN, y + 30), (width, box_height),
fill="#ffffff",
stroke=svgwrite.rgb(0, 0, 0)))
def Backward(self, length):
x1 = self.posX
y1 = self.posY
x2 = x1 - math.cos(math.radians(self.angle)) * length
y2 = y1 - math.sin(math.radians(self.angle)) * length
self.posX = x2
self.posY = y2
self.file.add(self.file.line((x1, y1), (x2, y2), stroke=svgwrite.rgb(self.color[0], self.color[1], self.color[2], '%'),
stroke_width = self.penStat))
def svgcreate(pairs, z, ymax, fillx, filly):
# Create a new SVG file with the file name as the z-coordinate (inches) of the slice (round to 0.001 in)
dwg = svgwrite.Drawing('outputs/' + str(round(z/25.4, 3)) + '.svg')
# Create lines for the geometry segment point pairs sliced on the given z-plane
for pair in pairs:
# Offset the y position by ymax-y in order to account for the difference in SVG coordinate system (+Y is down)
dwg.add(dwg.line((pair[0], ymax-pair[1]), (pair[2], ymax-pair[3]), stroke=svgwrite.rgb(0, 0, 0, "%")))
# Create lines for infill parallel to the Y axis
for fill_line in fillx:
# Loop over points for each fill line in X (always even number)
for pts in range(int(len(fill_line[1])/2)):
dwg.add(dwg.line((fill_line[0], ymax - fill_line[1][2*pts]), (fill_line[0], ymax - fill_line[1][2*pts+1]),
stroke=svgwrite.rgb(0, 0, 0, "%")))
# Create lines for infill parallel to the X axis
for fill_line in filly:
# Loop over points for each fill line in Y (always even number)
for pts in range(int(len(fill_line[1])/2)):
dwg.add(dwg.line((fill_line[1][2*pts], ymax - fill_line[0]), (fill_line[1][2*pts+1], ymax - fill_line[0]),
stroke=svgwrite.rgb(0, 0, 0, "%")))
dwg.save() # Save the SVG file to the output folder
def svg(self):
p = self.calcLines()
curve = svgwrite.container.Group()
for i in range(len(p) - 1):
curve.add(
svgwrite.shapes.Line(start=p[i],
end=p[i + 1],
stroke=svgwrite.rgb(10, 10, 16, '%')))
#pg.draw.line(screen, self.color, p[i], p[i+1], self.width)
return curve
def test_add_line_to_layer(dwg):
inkscape = Inkscape(dwg)
layer = inkscape.layer(label="Layer one", locked=True)
dwg.add(layer)
line = dwg.line((100, 100), (300, 100),
stroke=svgwrite.rgb(10, 10, 16, '%'),
stroke_width=10)
layer.add(line)
text = dwg.text('Test', insert=(100, 100), font_size=100, fill='red')
layer.add(text)
