def ApplyGlitchCollage(self, layer, groups, linecomponents):
for g in groups:
if len(g) < 2:
continue
templayer = GSLayer()
templayer.paths = g
G.remove_overlap(templayer)
linetype = False
for p in templayer.paths:
nodelen = len(p.nodes)
if nodelen < 4:
continue
roundedpath = RoundPath(p, "nodes")
roundedpath = convertToFitpath(roundedpath, True)
if not roundedpath:
continue
if random.choice([0, 1, 2, 3]) == 1:
tr = random.choice([0, 2])
if tr == 1:
self.HalftoneShape(layer, p, "triangle")
elif tr == 0:
self.HalftoneShape(layer, p, "square")
else:
layer.paths.append(roundedpath)
else:
if nodelen > 9:
if nodelen > 20:
noodlepaths = self.expandMonolineFromPathlist(
[roundedpath], 6)
AddAllPathsToLayer(noodlepaths, layer)
else:
if random.choice([0, 1]) == 0:
if linetype == False:
direction = "vertical"
else:
direction = "horizontal"
linetype = not linetype
linecomps = Fill_Drawlines(
layer, roundedpath, direction, 15,
linecomponents)
AddAllComponentsToLayer(linecomps, layer)
else:
self.Fill_Halftone(layer, roundedpath,
"circle")
else:
layer.paths.append(p)
del templayer
def newGlyph(self, glyphName, clear=True):
"""Make a new glyph"""
g = self._font.glyphForName_(glyphName)
if g is None:
g = GSGlyph(glyphName)
self._font.addGlyph_(g)
elif clear:
g.layers[self._masterKey] = GSLayer()
return self[glyphName]
def Fill_Halftone(self, thislayer): components = [] for size in range(0,5): font = self.font shapename = "pixel"+str(size) if font.glyphs[shapename]: del font.glyphs[shapename] ng = GSGlyph() ng.name = shapename ng.category = "Mark" ng.export = True font.glyphs.append(ng) firstmaster = font.masters[0].id thislayer = GSLayer() thislayer.layerId = thislayer.associatedMasterId =firstmaster ng.layers[firstmaster] = thislayer thislayer.width = 0 ox, oy = 0, 0 w, h = 40, 40 grid = 10 unit = 5 if size!=0: gridx = 10 * size gridy = gridx else: gridx = 10 gridy = 5 x, y = ox, oy switchx = False for x in range(ox, ox+w, gridx): for y in range(oy, oy+h, gridy): if switchx==True: if size==0: adjust = 5 switchx = not switchx else: adjust = gridx/2 switchx = not switchx else: adjust=0 switchx = not switchx ns = drawRectangle( x + adjust, y , unit, unit) thislayer.paths.append(ns) switchx = False components.append(ng) return components
def returnSlicedPaths(self, pathlist, sliceheight):
slicedpaths = []
tmplayer = GSLayer()
AddAllPathsToLayer(pathlist, tmplayer)
bounds = AllPathBounds(tmplayer)
ox, oy, w, h = bounds[0], bounds[1], bounds[2], bounds[3]
starty = int(oy/sliceheight) * sliceheight - 1
y = starty
sh = sliceheight
while y < starty+h:
G.cut_layer(tmplayer, (ox-1, y), (ox+w+1, y))
y+=sh
sh = sliceheight * random.randrange(1, 5)
slicedpaths = tmplayer.paths
del tmplayer
return slicedpaths
def __init__(self, glyph=None, master=0, layer=None):
self.masterIndex = master
self._layer = None
if type(glyph) == RGlyph:
self._object = glyph._object
self._layer = glyph._layer.copy()
self._layerID = glyph._layerID
if hasattr(glyph, "masterIndex"):
self.masterIndex = glyph.masterIndex
return
if layer is not None:
glyph = layer.parent
if glyph is None:
glyph = GSGlyph()
elif glyph.parent is not None:
self.setParent(RFont(glyph.parent, self.masterIndex))
self._object = glyph
self._layerID = None
if layer is None:
try:
if glyph.parent:
self._layerID = glyph.parent.masters[master].id
elif (glyph.layers[master]):
self._layerID = glyph.layers[master].layerId
except:
pass
self.masterIndex = master
if self._layerID:
self._layer = glyph.layerForKey_(self._layerID)
else:
self._layer = layer
self._layerID = layer.associatedMasterId
if self._layer is None:
self._layerID = "undefined"
self._layer = GSLayer()
glyph.setLayer_forKey_(self._layer, self._layerID)
def ApplyCollageGraphixxx(self, layer, groups, drawtype, linecomponents):
for g in groups:
if len(g) < 2:
continue
templayer = GSLayer()
templayer.paths = g
G.remove_overlap(templayer)
for p in templayer.paths:
nodelen = len(p.nodes)
if nodelen < 4:
continue
roundedpath = RoundPath(p, "nodes")
roundedpath = convertToFitpath(roundedpath, True)
if not roundedpath:
continue
if drawtype == "vertical" or drawtype == "horizontal":
rw = roundedpath.bounds.size.width
rh = roundedpath.bounds.size.height
if (rw > 130 or rh > 130):
all_lines = Fill_Drawlines(layer, roundedpath,
drawtype, 20,
linecomponents)
AddAllComponentsToLayer(all_lines, layer)
if drawtype == "blob":
# disallow small blobs
rw = roundedpath.bounds.size.width
rh = roundedpath.bounds.size.height
if (rw > 80 and rh > 80) and (rw < 180 or rh < 180):
ConvertPathDirection(roundedpath, -1)
layer.paths.append(roundedpath)
del templayer
def _get_indic_rightmost_stem(self, l):
stem_center = None
number_of_samples = 12
stem_width = self._indic_stem_widths.get(l.parent.script, {}).get(l.associatedMasterId)
if stem_width is None:
return
fuzziness = stem_width * 0.1
measure_interval = int(l.bounds.size.height / number_of_samples)
measure_heights = range(int(l.bounds.origin.y), int(l.bounds.origin.y + l.bounds.size.height), measure_interval)
potential_stems = defaultdict(list)
measured_points = []
# l.guides = []
for height in measure_heights:
for p in l.paths:
measure_l = GSLayer()
measure_l.width = l.width
measure_l.paths.append(p)
measured_points.append(measure_l.intersectionsBetweenPoints((0, height), (measure_l.width, height), components=True)[1:-1])
for c in l.components:
measure_l = c.componentLayer.copyDecomposedLayer()
measure_l.removeOverlap()
measure_l.applyTransform(c.transform)
measured_points.append(measure_l.intersectionsBetweenPoints((0, height), (measure_l.width + c.transform[4], height), components=True)[1:-1])
# if 1:
# ngl = GSGuideLine()
# ngl.position = NSPoint(0, height)
# ngl.setShowMeasurement_(1)
# l.guides.append(ngl)
# print(l, stem_width)
for measure_coords in measured_points:
for ci, coord in enumerate(measure_coords):
try:
next_coord = measure_coords[ci + 1]
except IndexError:
break
coord_distance = next_coord.x - coord.x
# print(coord_distance, measure_coords)
if self._check_coord(coord_distance, stem_width, fuzziness=fuzziness):
stem_mid_point = round((next_coord.x + coord.x) / 2)
stem_mid_point_max = stem_mid_point + fuzziness
stem_mid_point_min = stem_mid_point - fuzziness
added = False
for min_max in potential_stems.keys():
pmin, pmax = min_max
if pmax > stem_mid_point_max > pmin or pmax > stem_mid_point_min > pmin:
potential_stems[min_max].append(stem_mid_point)
added = True
break
if not added:
potential_stems[(stem_mid_point_min, stem_mid_point_max)].append(stem_mid_point)
vals = potential_stems.values()
vals.sort(reverse=True)
vals.sort(key=len, reverse=True)
stem_center = round(sum(vals[0]) / len(vals[0]))
return stem_center
def expandMonolineFromPathlist(self, Paths, noodleRadius):
Layer = GSLayer()
for p in Paths: Layer.paths.append(p)
G.offset_layer(Layer, noodleRadius, noodleRadius, make_stroke=True)
G.correct_path_direction(Layer)
return Layer.paths