Example #1
0
	def _curveToOne(self, bcp1, bcp2, pt):
		bounds = self.bounds
		bounds = updateBounds(bounds, pt)
		if not pointInRect(bcp1, bounds) or not pointInRect(bcp2, bounds):
			bounds = unionRect(bounds, calcCubicBounds(
					self._getCurrentPoint(), bcp1, bcp2, pt))
		self.bounds = bounds
Example #2
0
	def _curveToOne(self, bcp1, bcp2, pt):
		bounds = self.bounds
		bounds = updateBounds(bounds, pt)
		if not pointInRect(bcp1, bounds) or not pointInRect(bcp2, bounds):
			bounds = unionRect(bounds, calcCubicBounds(
					self._getCurrentPoint(), bcp1, bcp2, pt))
		self.bounds = bounds
Example #3
0
	def _checkBboxSegment(self, bcp1, bcp2, pt):
		# Like _checkBbox, but checks the whole segment and calculates extrema
		myRect = normRect((self._prev[0], self._prev[1], pt[0], pt[1]))
		if not pointInRect(bcp1, myRect) or not pointInRect(bcp2, myRect):
			extrema = getExtremaForCubic(self._prev, bcp1, bcp2, pt, h=True, v=True)
			for p in extrema:
				if self.extremum_calculate_badness:
					badness = self._getBadness(p, myRect)
					if badness >= self.extremum_ignore_badness_below:
						self.errors.append(OutlineError(p, "Extremum", badness))
				else:
					self.errors.append(OutlineError(p, "Extremum"))
 def _getSelectedPoints(self):
     if self.pStart and self.pEnd:
         box = self._normalizeBox(self.pStart, self.pEnd)
         for contour in self._glyph:
             for p in contour.onCurvePoints:
                 if pointInRect((p.x, p.y), box):
                     self.selection.addPoint(p,
                                             self.shiftDown,
                                             contour=contour)
                     self._selectedMouseDownPoint = (p.x, p.y)
         for anchor in self._glyph.anchors:
             if pointInRect((anchor.x, anchor.y), box):
                 self.selection.addAnchor(anchor, self.shiftDown)
                 self._selectedMouseDownPoint = (anchor.x, anchor.y)
 def _qCurveToOne(self, bcp, pt):
     bounds = self.bounds
     bounds = updateBounds(bounds, pt)
     if not pointInRect(bcp, bounds):
         bounds = unionRect(
             bounds, calcQuadraticBounds(self._getCurrentPoint(), bcp, pt))
     self.bounds = bounds
Example #6
0
def intersect(glyph, where, isHorizontal):
    """
    Intersection of a glyph with a horizontal or vertical line.
    Intersects each segment of a glyph using fontTools bezierTools.splitCubic and splitLine methods.
    """
    pen = CollectSegmentsPen()
    glyph.draw(pen)
    nakedGlyph = pen.getSegments()
    glyphIntersections = []

    for i, contour in enumerate(nakedGlyph):

        for segment in contour:

            length = len(segment)

            if length == 2:
                pt1, pt2 = segment
                returnedSegments = splitLine(pt1, pt2, where, int(isHorizontal))
            elif length == 4:
                pt1, pt2, pt3, pt4 = segment
                returnedSegments = bezierTools.splitCubic(pt1, pt2, pt3, pt4, where, int(isHorizontal))

            if len(returnedSegments) > 1:
                intersectionPoints = findDuplicatePoints(returnedSegments)
                if len(intersectionPoints):
                    box = calcBounds(segment)
                    intersectionPoints = [point for point in intersectionPoints if arrayTools.pointInRect(point, box)]
                    glyphIntersections.extend(intersectionPoints)

    return glyphIntersections
Example #7
0
def intersect(glyph, where, isHorizontal):
    """
    Intersect a glyph with a horizontal or vertical line.
    Intersect each segment of a glyph using fontTools bezierTools.splitCubic and splitLine methods.
    """
    pen = CollectSegmentsPen(glyph.layer)
    glyph.draw(pen)
    nakedGlyph = pen.getSegments()
    glyphIntersections = []

    for i, contour in enumerate(nakedGlyph):

        for segment in contour:

            length = len(segment)

            if length == 2:
                pt1, pt2 = segment
                returnedSegments = splitLine(pt1, pt2, where, int(isHorizontal))
            elif length == 4:
                pt1, pt2, pt3, pt4 = segment
                returnedSegments = bezierTools.splitCubic(pt1, pt2, pt3, pt4, where, int(isHorizontal))

            if len(returnedSegments) > 1:
                intersectionPoints = findDuplicatePoints(returnedSegments)
                if len(intersectionPoints):
                    box = calcBounds(segment)
                    intersectionPoints = [point for point in intersectionPoints if arrayTools.pointInRect(point, box)]
                    glyphIntersections.extend(intersectionPoints)

    return glyphIntersections
Example #8
0
	def _qCurveToOne(self, bcp, pt):
		bounds = self.bounds
		bounds = updateBounds(bounds, pt)
		if not pointInRect(bcp, bounds):
			bounds = unionRect(bounds, calcQuadraticBounds(
					self._getCurrentPoint(), bcp, pt))
		self.bounds = bounds
Example #9
0
def pointBoundTouche(point, bounds):
    found = pointInRect(point, bounds)
    if not found:
        # lazy check x values only
        minX, minY, maxX, maxY = bounds
        found = minX <= point[0] <= maxX
    return found
def pointBoundTouche(point, bounds):
    found = pointInRect(point, bounds)
    if not found:
        # lazy check x values only
        minX, minY, maxX, maxY = bounds
        found = minX <= point[0] <= maxX
    return found
Example #11
0
 def _getSelectedPoints(self):
     if self.pStart and self.pEnd:
         box = self._normalizeBox(self.pStart, self.pEnd)
         for error in self.ui.errors:
             p = error.position
             if pointInRect(p, box):
                 self.errorSelection.addError(p, self.shiftDown)
                 self._selectedMouseDownPoint = p
Example #12
0
 def _getSelectedPoints(self):
     if self.pStart and self.pEnd:
         box = self._normalizeBox(self.pStart, self.pEnd)
         for error in self.ui.errors:
             p = error.position
             if pointInRect(p, box):
                 self.errorSelection.addError(p, self.shiftDown)
                 self._selectedMouseDownPoint = p
Example #13
0
 def _checkBboxSegment(self, bcp1, bcp2, pt):
     # Like _checkBbox, but checks the whole segment and calculates extrema
     myRect = normRect((self._prev[0], self._prev[1], pt[0], pt[1]))
     if not pointInRect(bcp1, myRect) or not pointInRect(bcp2, myRect):
         extrema = getExtremaForCubic(self._prev,
                                      bcp1,
                                      bcp2,
                                      pt,
                                      h=True,
                                      v=True)
         for p in extrema:
             if self.extremum_calculate_badness:
                 badness = self._getBadness(p, myRect)
                 if badness >= self.extremum_ignore_badness_below:
                     self.errors.append(OutlineError(
                         p, "Extremum", badness))
             else:
                 self.errors.append(OutlineError(p, "Extremum"))
Example #14
0
	def recalcBounds(self, glyfTable):
		coords, endPts, flags = self.getCoordinates(glyfTable)
		if len(coords) > 0:
			if 0:
				# This branch calculates exact glyph outline bounds
				# analytically, handling cases without on-curve
				# extremas, etc.  However, the glyf table header
				# simply says that the bounds should be min/max x/y
				# "for coordinate data", so I suppose that means no
				# fancy thing here, just get extremas of all coord
				# points (on and off).  As such, this branch is
				# disabled.

				# Collect on-curve points
				onCurveCoords = [coords[j] for j in range(len(coords))
						 if flags[j] & flagOnCurve]
				# Add implicit on-curve points
				start = 0
				for end in endPts:
					last = end
					for j in range(start, end + 1):
						if not ((flags[j] | flags[last]) & flagOnCurve):
							x = (coords[last][0] + coords[j][0]) / 2
							y = (coords[last][1] + coords[j][1]) / 2
							onCurveCoords.append((x,y))
						last = j
					start = end + 1
				# Add bounds for curves without an explicit extrema
				start = 0
				for end in endPts:
					last = end
					for j in range(start, end + 1):
						if not (flags[j] & flagOnCurve):
							next = j + 1 if j < end else start
							bbox = calcBounds([coords[last], coords[next]])
							if not pointInRect(coords[j], bbox):
								# Ouch!
								warnings.warn("Outline has curve with implicit extrema.")
								# Ouch!  Find analytical curve bounds.
								pthis = coords[j]
								plast = coords[last]
								if not (flags[last] & flagOnCurve):
									plast = ((pthis[0]+plast[0])/2, (pthis[1]+plast[1])/2)
								pnext = coords[next]
								if not (flags[next] & flagOnCurve):
									pnext = ((pthis[0]+pnext[0])/2, (pthis[1]+pnext[1])/2)
								bbox = calcQuadraticBounds(plast, pthis, pnext)
								onCurveCoords.append((bbox[0],bbox[1]))
								onCurveCoords.append((bbox[2],bbox[3]))
						last = j
					start = end + 1

				self.xMin, self.yMin, self.xMax, self.yMax = calcIntBounds(onCurveCoords)
			else:
				self.xMin, self.yMin, self.xMax, self.yMax = calcIntBounds(coords)
		else:
			self.xMin, self.yMin, self.xMax, self.yMax = (0, 0, 0, 0)
	def recalcBounds(self, glyfTable):
		coords, endPts, flags = self.getCoordinates(glyfTable)
		if len(coords) > 0:
			if 0:
				# This branch calculates exact glyph outline bounds
				# analytically, handling cases without on-curve
				# extremas, etc.  However, the glyf table header
				# simply says that the bounds should be min/max x/y
				# "for coordinate data", so I suppose that means no
				# fancy thing here, just get extremas of all coord
				# points (on and off).  As such, this branch is
				# disabled.

				# Collect on-curve points
				onCurveCoords = [coords[j] for j in range(len(coords))
						 if flags[j] & flagOnCurve]
				# Add implicit on-curve points
				start = 0
				for end in endPts:
					last = end
					for j in range(start, end + 1):
						if not ((flags[j] | flags[last]) & flagOnCurve):
							x = (coords[last][0] + coords[j][0]) / 2
							y = (coords[last][1] + coords[j][1]) / 2
							onCurveCoords.append((x,y))
						last = j
					start = end + 1
				# Add bounds for curves without an explicit extrema
				start = 0
				for end in endPts:
					last = end
					for j in range(start, end + 1):
						if not (flags[j] & flagOnCurve):
							next = j + 1 if j < end else start
							bbox = calcBounds([coords[last], coords[next]])
							if not pointInRect(coords[j], bbox):
								# Ouch!
								warnings.warn("Outline has curve with implicit extrema.")
								# Ouch!  Find analytical curve bounds.
								pthis = coords[j]
								plast = coords[last]
								if not (flags[last] & flagOnCurve):
									plast = ((pthis[0]+plast[0])/2, (pthis[1]+plast[1])/2)
								pnext = coords[next]
								if not (flags[next] & flagOnCurve):
									pnext = ((pthis[0]+pnext[0])/2, (pthis[1]+pnext[1])/2)
								bbox = calcQuadraticBounds(plast, pthis, pnext)
								onCurveCoords.append((bbox[0],bbox[1]))
								onCurveCoords.append((bbox[2],bbox[3]))
						last = j
					start = end + 1

				self.xMin, self.yMin, self.xMax, self.yMax = calcIntBounds(onCurveCoords)
			else:
				self.xMin, self.yMin, self.xMax, self.yMax = calcIntBounds(coords)
		else:
			self.xMin, self.yMin, self.xMax, self.yMax = (0, 0, 0, 0)
Example #16
0
def segmentInBound(segment, bounds):
    minX, minY, maxX, maxY = bounds
    for point in segment:
        if pointInRect(point, bounds):
            return True
        found = minX <= point[0] <= maxX
        if found:
            return True
    return False
Example #17
0
def segmentInBound(segment, bounds):
    minX, minY, maxX, maxY = bounds
    for point in segment:
        if pointInRect(point, bounds):
            return True
        found = minX <= point[0] <= maxX
        if found:
            return True
    return False
Example #18
0
	def _checkBbox(self, pointToCheck, boxPoint):
		# boxPoint is the final point of the current node,
		# the other bbox point is the previous final point
		myRect = normRect((self._prev[0], self._prev[1], boxPoint[0], boxPoint[1]))
		if not pointInRect(pointToCheck, myRect):
			if self.extremum_calculate_badness:
				badness = self._getBadness(pointToCheck, myRect)
				if badness >= self.extremum_ignore_badness_below:
					self.errors.append(OutlineError(pointToCheck, "Extremum", badness))
			else:
				self.errors.append(OutlineError(pointToCheck, "Extremum"))
Example #19
0
 def _checkBbox(self, pointToCheck, boxPoint):
     # boxPoint is the final point of the current node,
     # the other bbox point is the previous final point
     myRect = normRect(
         (self._prev[0], self._prev[1], boxPoint[0], boxPoint[1]))
     if not pointInRect(pointToCheck, myRect):
         if self.extremum_calculate_badness:
             badness = self._getBadness(pointToCheck, myRect)
             if badness >= self.extremum_ignore_badness_below:
                 self.errors.append(
                     OutlineError(pointToCheck, "Extremum", badness))
         else:
             self.errors.append(OutlineError(pointToCheck, "Extremum"))
 def findObjectInGlyphForPoint(self, glyph, point):
     found = None
     if self.drawingMode == COMPONENT_MODE:
         size = self.size
         for component in glyph.components:
             if component.baseGlyph != self.componentName:
                 continue
             rect = component.box
             if pointInRect(point, rect):
                 found = component
                 break
     else:
         for contour in glyph:
             if contour.pointInside(point):
                 found = contour
                 break
     return found
 def findObjectInGlyphForPoint(self, glyph, point):
     found = None
     if self.drawingMode == COMPONENT_MODE:
         size = self.size
         for component in glyph.components:
             if component.baseGlyph != self.componentName:
                 continue
             rect = component.box
             if pointInRect(point, rect):
                 found = component
                 break
     else:
         for contour in glyph:
             if contour.pointInside(point):
                 found = contour
                 break
     return found
 def mouseUp(self, info):
     # get the glyph
     glyph = info["glyph"]
     # get the current tool
     tool = info["tool"]
     # only work when the curren tools is the editingTool
     if not isinstance(tool, EditingTool):
         return
     # go on when the option is down and there is no point selection in the glyph
     if tool.optionDown and not glyph.selection:
         # get the marque rect from the tool
         (x, y), (w, h) = tool.getMarqueRect()
         # normalize the rect to a minx, miny, maxx, maxy rectangle
         marqueRect = normRect((x, y, x + w, y + h))
         # loop over all components
         for component in glyph.components:
             # get the component bounding box
             comonentBounds = component.box
             # empty components are possible
             if comonentBounds:
                 # check if there an intersection between the marque rect and the component bounding box
                 interesect, intersectionRect = sectRect(marqueRect, component.box)
                 # if so...
                 if interesect:
                     # check if shift is down
                     if tool.shiftDown:
                         # on shift down, just toggle the current selection
                         component.selected = not component.selected
                     else:
                         # othewise set the component as selected
                         component.selected = True
             else:
                 # empty component
                 # check if the off set point of the component is inside the marque rect
                 if pointInRect(component.offset, marqueRect):
                     # check if shift is down
                     if tool.shiftDown:
                         # on shift down, just toggle the current selection
                         component.selected = not component.selected
                     else:
                         # othewise set the component as selected
                         component.selected = True
         # update the glyph
         glyph.update()
Example #23
0
def test_pointInRect():
    assert pointInRect((50, 50), (0, 0, 100, 100))
    assert pointInRect((0, 0), (0, 0, 100, 100))
    assert pointInRect((100, 100), (0, 0, 100, 100))
    assert not pointInRect((101, 100), (0, 0, 100, 100))
Example #24
0
def test_pointInRect():
    assert pointInRect((50, 50), (0, 0, 100, 100))
    assert pointInRect((0, 0), (0, 0, 100, 100))
    assert pointInRect((100, 100), (0, 0, 100, 100))
    assert not pointInRect((101, 100), (0, 0, 100, 100))