Пример #1
0
def getVerticalLinearizedSkeletonPath(comps1, comps2, offs, isLine):
    path = []
    lengths = []
    
    if isLine:
        for pt1 in comps1:
            pt2 = getPtsByY(pt1, comps2, False)
            midPt = getMidPoint(pt1, pt2)
            
            if offs > 0:
                dist = bezmisc.pointdistance(pt1, pt2)
                path.append(getPtOnSeg(pt1, pt2, dist, offs * dist))
            else:
                path.append(midPt)
            
            if len(path) > 1:
                lengths.append(bezmisc.pointdistance(path[-2], path[-1]))
    else:
        pt1 = comps1[0]
        pt2 = comps2[0]
        
        firstPt = getMidPoint(pt1, pt2)
        path.append(firstPt)
        
        lastPt = [firstPt[0], comps1[-1][1]]
        path.append(lastPt)
        
        lengths.append(bezmisc.pointdistance(path[-2], path[-1]))
    
    return (path, lengths)
Пример #2
0
def linearize(p,tolerance=0.001):
    '''
    This function receives a component of a 'cubicsuperpath' and returns two things:
    The path subdivided in many straight segments, and an array containing the length of each segment.
    
    We could work with bezier path as well, but bezier arc lengths are (re)computed for each point 
    in the deformed object. For complex paths, this might take a while.
    '''
    zero=0.000001
    i=0
    d=0
    lengths=[]
    while i<len(p)-1:
        box  = bezmisc.pointdistance(p[i  ][1],p[i  ][2])
        box += bezmisc.pointdistance(p[i  ][2],p[i+1][0])
        box += bezmisc.pointdistance(p[i+1][0],p[i+1][1])
        chord = bezmisc.pointdistance(p[i][1], p[i+1][1])
        if (box - chord) > tolerance:
            b1, b2 = bezmisc.beziersplitatt([p[i][1],p[i][2],p[i+1][0],p[i+1][1]], 0.5)
            p[i  ][2][0],p[i  ][2][1]=b1[1]
            p[i+1][0][0],p[i+1][0][1]=b2[2]
            p.insert(i+1,[[b1[2][0],b1[2][1]],[b1[3][0],b1[3][1]],[b2[1][0],b2[1][1]]])
        else:
            d=(box+chord)/2
            lengths.append(d)
            i+=1
    new=[p[i][1] for i in range(0,len(p)-1) if lengths[i]>zero]
    new.append(p[-1][1])
    lengths=[l for l in lengths if l>zero]
    return(new,lengths)
Пример #3
0
def linearize(p, tolerance=0.001):
    '''
    This function receives a component of a 'cubicsuperpath' and returns two things:
    The path subdivided in many straight segments, and an array containing the length of each segment.
    
    We could work with bezier path as well, but bezier arc lengths are (re)computed for each point 
    in the deformed object. For complex paths, this might take a while.
    '''
    zero = 0.000001
    i = 0
    d = 0
    lengths = []
    while i < len(p) - 1:
        box = bezmisc.pointdistance(p[i][1], p[i][2])
        box += bezmisc.pointdistance(p[i][2], p[i + 1][0])
        box += bezmisc.pointdistance(p[i + 1][0], p[i + 1][1])
        chord = bezmisc.pointdistance(p[i][1], p[i + 1][1])
        if (box - chord) > tolerance:
            b1, b2 = bezmisc.beziersplitatt(
                [p[i][1], p[i][2], p[i + 1][0], p[i + 1][1]], 0.5)
            p[i][2][0], p[i][2][1] = b1[1]
            p[i + 1][0][0], p[i + 1][0][1] = b2[2]
            p.insert(i + 1, [[b1[2][0], b1[2][1]], [b1[3][0], b1[3][1]],
                             [b2[1][0], b2[1][1]]])
        else:
            d = (box + chord) / 2
            lengths.append(d)
            i += 1
    new = [p[i][1] for i in range(0, len(p) - 1) if lengths[i] > zero]
    new.append(p[-1][1])
    lengths = [l for l in lengths if l > zero]
    return (new, lengths)
Пример #4
0
def pickCorrespPt(cntr, p, pts):
    tmpPts = []
    
    for pt in pts:
        if (p[0] >= cntr[0] and p[1] >= cntr[1]):
            if (pt[0] >= cntr[0] and pt[1] >= cntr[1]):
                tmpPts.append(pt)
        elif (p[0] <= cntr[0] and p[1] <= cntr[1]):
            if (pt[0] <= cntr[0] and pt[1] <= cntr[1]):
                tmpPts.append(pt)
        elif (p[0] < cntr[0] and p[1] > cntr[1]):
            if (pt[0] <= cntr[0] and pt[1] >= cntr[1]):
                tmpPts.append(pt)
        else:
            if (pt[0] >= cntr[0] and pt[1] <= cntr[1]):
                tmpPts.append(pt)
    
    cntPts = len(tmpPts)
    resPt = tmpPts[0]
    
    if cntPts > 1:
        shortestDist = bezmisc.pointdistance(p, tmpPts[0])
        shortI = 0
        
        for i in range(1, cntPts):
            tmpDist = bezmisc.pointdistance(p, tmpPts[i])
            
            if tmpDist < shortestDist:
                shortestDist = tmpDist
                shortI = i
        
        resPt = tmpPts[shortI]
    
    return resPt
Пример #5
0
def getClosedLinearizedSkeletonPath(comps1, comps2, offs, isLine):
    path = []
    lengths = []
    
    centroid = getPolygonCentroid(comps1)
    
    if isLine:
        for pt2 in comps2:
            pt1 = getIntersectionPt(centroid, pt2, comps1)
            midPt = getMidPoint(pt1, pt2)
            
            if offs > 0:
                dist = bezmisc.pointdistance(pt1, pt2)
                path.append(getPtOnSeg(pt1, pt2, dist, offs * dist))
            else:
                path.append(midPt)
            
            if len(path) > 1:
                lengths.append(bezmisc.pointdistance(path[-2], path[-1]))
    else:
        pt1 = comps1[0]
        pt2 = getIntersectionPt(centroid, pt1, comps2)
        midPt = getMidPoint(pt1, pt2)
        rx = bezmisc.pointdistance(centroid, midPt)
        
        svgPath = getCirclePath(midPt, rx)
        
        path, lengths = linearize(modifySkeletonPath(cubicsuperpath.parsePath(svgPath)))
    
    return (path, lengths)
Пример #6
0
	def applyToAdjacent(self, point):
		while point != None:
			p = (point[0], point[1])
			next = None
			for item in self.candidates:
				if  bezmisc.pointdistance(p, (item['s'][0], item['s'][1])) < self.options.tolerance:
					self.applyStyle(item)
					next = item['e']
					break
				elif bezmisc.pointdistance(p, (item['e'][0], item['e'][1])) < self.options.tolerance:
					self.applyStyle(item)
					next = item['s']
					break
			point = next
 def applyToAdjacent(self, point):
     while point != None:
         p = (point[0], point[1])
         next = None
         for item in self.candidates:
             if bezmisc.pointdistance(
                     p,
                 (item['s'][0], item['s'][1])) < self.options.tolerance:
                 self.applyStyle(item)
                 next = item['e']
                 break
             elif bezmisc.pointdistance(
                     p,
                 (item['e'][0], item['e'][1])) < self.options.tolerance:
                 self.applyStyle(item)
                 next = item['s']
                 break
         point = next
Пример #8
0
 def linearizePath(self, skelPath, offs):
     comps, lengths = linearize(skelPath)
     
     self.skelCompIsClosed = isSkeletonClosed(comps)
     
     if (self.skelCompIsClosed and offs != 0):
         centroid = getPolygonCentroid(comps)
         
         for i in range(len(comps)):
             pt1 = comps[i]
             dist = bezmisc.pointdistance(centroid, pt1)
             
             comps[i] = getPtOnSeg(centroid, pt1, dist, dist + offs)
             
             if i > 0:
                 lengths[i - 1] = bezmisc.pointdistance(comps[i - 1], comps[i])
     
     return (comps, lengths)
Пример #9
0
 def getPathLength(self):  # close enough...
     poly = self.toPolyline()
     i = 1
     d = 0
     while i < len(poly):
         last = poly[i - 1][1]
         cur = poly[i][1]
         d += bezmisc.pointdistance(last, cur)
         i += 1
     return d
Пример #10
0
	def getPathLength(self): # close enough...
		poly = self.toPolyline()
		i = 1
		d = 0
		while i < len(poly):
			last = poly[i-1][1]
			cur = poly[i][1]
			d += bezmisc.pointdistance(last,cur)
			i+=1
		return d
Пример #11
0
 def computeOffsets(
         self,
         usedistance=False,
         distance=50.0,
         distbetween='centers'):  #as distances from 0.0, 'centers bboxes'
     retval = []
     centers = self.centers
     retval.append(0.0)
     for i in xrange(len(centers) - 1):
         retval.append((bezmisc.pointdistance(
             (centers[i + 1][1], centers[i + 1][2]),
             (centers[i][1], centers[i][2])) + retval[-1]))
     return retval
Пример #12
0
def distances(points):
    """Calculate the distances for a list of points
    :param points:	iterable of float pairs
    :return:		list of distance
    """
    if not points:
        return [0]
    lastpt = points[0]
    dists = []
    for pt in points[1:]:
        dists.append(bezmisc.pointdistance(lastpt, pt))
        lastpt = pt
    return dists
Пример #13
0
def getPtsByY(pt, comps, isClosed):
    res = []
    
    for i in range(1, len(comps)):
        if ((comps[i - 1][1] <= pt[1] and pt[1] <= comps[i][1]) or (comps[i - 1][1] >= pt[1] and pt[1] >= comps[i][1])):
            if comps[i - 1][1] == comps[i][1]:
                d1 = bezmisc.pointdistance(pt, comps[i - 1])
                d2 = bezmisc.pointdistance(pt, comps[i])
                
                if d1 < d2:
                    res.append(comps[i - 1])
                else:
                    res.append(comps[i])
            elif comps[i - 1][0] == comps[i][0]:
                res.append([comps[i - 1][0], pt[1]])
            else:
                res.append(getPoint(comps[i - 1], comps[i], None, pt[1]))
            
            if not isClosed:
                return res[0]
    
    return res
Пример #14
0
def getDistBetweenFirstPts(comps1, comps2, bbox1, bbox2, nest):
    pt1 = comps1[0]
    pt2 = None
    
    if (bbox1[0] == bbox2[0] and bbox1[1] == bbox2[1]):
        pt2 = getPtsByX(pt1, comps2, False)
    elif (bbox1[2] == bbox2[2] and bbox1[3] == bbox2[3]):
        pt2 = getPtsByY(pt1, comps2, False)
    elif nest:
        centroid = getPolygonCentroid(comps1)
        pt2 = getIntersectionPt(centroid, pt1, comps2)
    
    dist = bezmisc.pointdistance(pt1, pt2)
    
    return dist
Пример #15
0
    def applyOvercut(self, poly):  # good old polyline overcut...
        d = self.overcut
        if self.closed and d > 0:
            # find overcut point d away from start, todo, don't use polylines, see setOvecut commented...
            i = 1  # skip move to
            last = poly[0][1][:]  # start position
            while d > 0:
                cur = poly[i][1][:]
                cmd = poly[i][0]
                # get distance to next point
                dist = bezmisc.pointdistance(last, cur)
                # check distance
                if d < dist:  # last point
                    t = d / dist
                    poly.append(['L', list(bezmisc.tpoint(last, cur, t))])
                else:
                    poly.append([cmd, cur])

                # update last
                last = cur
                d -= dist
                i += 1
        return poly
Пример #16
0
	def applyOvercut(self,poly): # good old polyline overcut...
		d = self.overcut
		if self.closed and d > 0:
			# find overcut point d away from start, todo, don't use polylines, see setOvecut commented...
			i = 1 # skip move to
			last = poly[0][1][:]  # start position
			while d > 0:
				cur = poly[i][1][:]
				cmd = poly[i][0]
				# get distance to next point
				dist = bezmisc.pointdistance(last,cur)				
				# check distance
				if d<dist: # last point
					t = d/dist
					poly.append(['L',list(bezmisc.tpoint(last,cur,t))])
				else: 
					poly.append([cmd,cur])
				
				# update last
				last = cur
				d -= dist
				i +=1
		return poly
Пример #17
0
class Path:  # a single path
    def __init__(self, basicpath, settings={}):
        default = {
            'overcut': 0,
            'offset': 0,
            'smoothness': .1 * units['mm'],  # 1 um
            'scale': 1016 / units['in']
        }
        default.update(settings)
        for k, v in default.iteritems():
            setattr(self, k, v)
        self.data = basicpath
        self.closed = self.isClosed()

        #self.smoothness = .1
        self.bbox = self.boundingBox()
        #self.length = self.getPathLength()
        #self.position = (self.bbox[0],self.bbox[2])
        #self.scale = 11.288888889

    # --------------------------path adjustments --------------------------

    def translatePath(self, x, y):
        simplepath.translatePath(self.data, x, y)

    def rotatePath(self, a, x=0, y=0):
        simplepath.rotatePath(self.data, a, x, y)

    def scalePath(self, x, y):
        simplepath.scalePath(self.data, x, y)

    # --------------------------path properties --------------------------
    def boundingBox(self):
        csp = cubicsuperpath.CubicSuperPath(self.data)
        self.bbox = list(simpletransform.roughBBox(csp))
        return list(simpletransform.roughBBox(csp))  # [minx,maxx,miny,maxy]

    def getPathLength(self):  # close enough...
        poly = self.toPolyline()
        i = 1
        d = 0
        while i < len(poly):
            last = poly[i - 1][1]
            cur = poly[i][1]
            d += bezmisc.pointdistance(last, cur)
            i += 1
        return d

    def isClosed(self):
        try:
            return self.closed
        except:
            ans = self.data[-1][0] == "Z"
            self.closed = ans
            return ans

    # --------------------------path settings --------------------------
    def setSmoothness(self, s):
        self.smoothness = s

    def setScale(self, s):
        self.scale = s

    def setBladeOffset(self, d):
        self.offset = d

    def setOvercut(self, d):
        self.overcut = d

        if self.closed and d > 0:
            # replace z with the start point
            """
			pprint(self.data)
			endp = self.data.pop()
			if endp[0]=='Z':
				endp = ['L',self.data[0][1]]
				self.data.append(endp)
			"""
        # below does not work, beziersplitatt does not give the correct bezier....
        """
		if self.closed and d > 0:
			# replace z with the start point
			self.data.pop()
			endp = ['L',self.data[0][1]]
			self.data.append(endp)
			
			# find overcut point d away from start, todo, don't use polylines
			i = 1
			last = self.data[0][1][:]  # start position
			while d > 0:
				cur = self.data[i][1][:]
				cmd = self.data[i][0]
				# get distance to next point
				if cmd=='L':
					dist = bezmisc.pointdistance(last,cur)
				elif cmd=='C':
					curve = ((cur[0],cur[1]),(cur[2],cur[3]),(cur[4],cur[5]),last)
					dist = bezmisc.bezierlength(curve)
				
				# check distance
				if d<dist: # last point
					t = d/dist
					if cmd=='L':
						self.data.append(['L',list(bezmisc.tpoint(last,cur,t))])
					elif cmd=='C':
						curve = ((cur[0],cur[1]),(cur[2],cur[3]),(cur[4],cur[5]),last)
						first,second = bezmisc.beziersplitatt(curve,t)
						self.data.append(['C',[first[0][0],first[0][1],first[1][0],first[1][1],first[2][0],first[2][1]]])
				else: 
					self.data.append([cmd,cur])
				
				# update last
				if cmd=='L':
					last = cur
				elif cmd=='C':	
					last = [cur[4],cur[5]]
				d -= dist
				i +=1
			"""

    #--------------------------apply path changes --------------------------

    def applyOvercut(self, poly):  # good old polyline overcut...
        d = self.overcut
        if self.closed and d > 0:
            # find overcut point d away from start, todo, don't use polylines, see setOvecut commented...
            i = 1  # skip move to
            last = poly[0][1][:]  # start position
            while d > 0:
                cur = poly[i][1][:]
                cmd = poly[i][0]
                # get distance to next point
                dist = bezmisc.pointdistance(last, cur)
                # check distance
                if d < dist:  # last point
                    t = d / dist
                    poly.append(['L', list(bezmisc.tpoint(last, cur, t))])
                else:
                    poly.append([cmd, cur])

                # update last
                last = cur
                d -= dist
                i += 1
        return poly

    def applyOffset(self, poly):  # adjust for blade offset
        #todo, this haha
        d = abs(self.offset)

        def angleBetween(axis, p0, p1):
            def dotP(p0, p1):
                p = 0
                for a1, a2 in zip(p0, p1):
                    p += a1 * a2
                return p

            def norm(p0):
                n = 0
                for a in p0:
                    n += a * a
                return math.sqrt(n)

            p0 = [p0[0] - axis[0], p0[1] - axis[1]]
            p1 = [p1[0] - axis[0], p1[1] - axis[1]]
            assert norm(p0) > 0 and norm(p1) > 0, "invalid points"
            r = dotP(p0, p1) / (norm(p0) * norm(p1))
            if -1 <= r <= 1:
                return math.acos(r)
            else:
                return math.pi

        def arcto(radius, theta, (x, y), p0):
            poly = []
            arc = ['A', [radius, radius, theta, 0, 0, x, y]]
            d = simplepath.formatPath([['M', p0], arc])
            p = cubicsuperpath.parsePath(d)
            cspsubdiv.cspsubdiv(p, self.smoothness)
            for sp in p:
                first = True
                for csp in sp:
                    if first:
                        first = False
                    else:
                        for subpath in csp:
                            poly.append(['L', list(subpath)])
            return poly

        def curveto(p0, curve, flat):
            poly = []
            d = simplepath.formatPath([['M', p0], curve])
            p = cubicsuperpath.parsePath(d)
            cspsubdiv.cspsubdiv(p, flat)
            for sp in p:
                first = True
                for csp in sp:
                    if first:
                        first = False
                    else:
                        for subpath in csp:
                            poly.append(['L', list(subpath)])
            return poly

        if d <= 0:
            return poly

        # start position
        last = poly[0][1][:]
        cur = poly[1][1][:]
        i = 2
        while i < len(poly):
            next = poly[i][1][:]
            # skip double points
            if not last == cur and not cur == next:  # where are doubles coming from?
                # get the angle between the two vectors using cur as origin
                theta = angleBetween(cur, last, next)
                if theta < math.pi / 1.1:
                    # go past by offset amount
                    dist = bezmisc.pointdistance(last, cur)
                    t1 = d / dist + 1
                    start = bezmisc.tpoint(last, cur, t1)

                    # come back to next line
                    dist = bezmisc.pointdistance(cur, next)
                    t2 = (4 * d) / dist
                    finish = bezmisc.tpoint(cur, next, t2)
                    if t2 <= 1:
                        # add cur point
                        poly.insert(i - 1, ['L', list(start)])
                        i += 1
                        poly[i - 1] = ['L', list(finish)]

            #else:
            #	inkex.debug("failed on %i with points %s,%s and %s"%(i,last,cur,next))

            # shift to next point
            last = cur[:]
            cur = next[:]
            i += 1

        return poly
Пример #18
0
            return hpgl

        #poly = hpgl.parse(hpgl)

        last = ['PU', [0, 0]]  # start position
        cur = [hpgl[0][:2], map(int, hpgl[0][2:].split(','))]
        i = 1
        while i < len(hpgl):
            cmd = hpgl[i][:2]
            point = map(int, hpgl[i][2:].split(','))
            next = [cmd, point]
            if not last[1] == cur[1] and not cur[1] == next[1]:
                theta = angleBetween(cur[1], last[1], next[1])
                if theta < math.pi / 1.1:
                    # start point
                    dist = bezmisc.pointdistance(last[1], cur[1])
                    t = d / dist + 1
                    start = bezmisc.tpoint(last[1], cur[1], t)
                    # end point
                    dist = bezmisc.pointdistance(cur[1], next[1])
                    t = (4 * d) / dist
                    end = bezmisc.tpoint(cur[1], next[1], t)
                    if t <= 1:
                        # go distance d past actual point
                        hpgl[i - 1] = '%s%d,%d' % (cur[0], start[0], start[1])

                        # curve to end point
                        #for pt in arcto(d,0,end,start):
                        #	hpgl.insert(i,'%s%d,%d'%(cur[0],pt[0],pt[1]))
                        #	i+=1
Пример #19
0
def stretchComps(skelComps, patComps, comps1, comps2, bbox1, bbox2, nest, halfHeight, ampl, offs):
    res = []
    
    if nest:
        newPt = None
        centroid = getPolygonCentroid(comps1)
        
        for pt in patComps:
            skelPt = getIntersectionPt(centroid, pt, skelComps)
            pt1 = getIntersectionPt(centroid, pt, comps1)
            pt2 = getIntersectionPt(centroid, pt, comps2)
            midPt = getMidPoint(pt1, pt2)
            
            dist1 = bezmisc.pointdistance(skelPt, pt)
            dist2 = bezmisc.pointdistance(midPt, pt1) * ampl
            dist3 = dist2 * dist1 / halfHeight
            
            if (skelPt[0] >= centroid[0] and skelPt[1] >= centroid[1]):
                if (pt[0] >= skelPt[0] and pt[1] >= skelPt[1]):
                    newPt = getPtOnSeg(midPt, pt2, bezmisc.pointdistance(midPt, pt2), dist3 + offs)
                else:
                    newPt = getPtOnSeg(midPt, pt1, bezmisc.pointdistance(midPt, pt1), dist3 - offs)
            elif (skelPt[0] <= centroid[0] and skelPt[1] <= centroid[1]):
                if (pt[0] <= skelPt[0] and pt[1] <= skelPt[1]):
                    newPt = getPtOnSeg(midPt, pt2, bezmisc.pointdistance(midPt, pt2), dist3 + offs)
                else:
                    newPt = getPtOnSeg(midPt, pt1, bezmisc.pointdistance(midPt, pt1), dist3 - offs)
            elif (skelPt[0] < centroid[0] and skelPt[1] > centroid[1]):
                if (pt[0] <= skelPt[0] and pt[1] >= skelPt[1]):
                    newPt = getPtOnSeg(midPt, pt2, bezmisc.pointdistance(midPt, pt2), dist3 + offs)
                else:
                    newPt = getPtOnSeg(midPt, pt1, bezmisc.pointdistance(midPt, pt1), dist3 - offs)
            else:
                if (pt[0] >= skelPt[0] and pt[1] <= skelPt[1]):
                    newPt = getPtOnSeg(midPt, pt2, bezmisc.pointdistance(midPt, pt2), dist3 + offs)
                else:
                    newPt = getPtOnSeg(midPt, pt1, bezmisc.pointdistance(midPt, pt1), dist3 - offs)
            
            res.append(newPt)
    elif (bbox1[0] == bbox2[0] and bbox1[1] == bbox2[1]):
        midY = skelComps[0][1]
        newPt = None
        
        if (patComps[-1][0] != comps1[-1][0] and round(patComps[-1][0], 10) == comps1[-1][0]):
            patComps[-1][0] = comps1[-1][0]
        
        for pt in patComps:
            pt1 = getPtsByX(pt, comps1, False)
            pt2 = getPtsByX(pt, comps2, False)
            midPt = getMidPoint(pt1, pt2)
            
            dist1 = abs(pt[1] - midY)
            dist2 = bezmisc.pointdistance(midPt, pt1) * ampl
            dist3 = dist2 * dist1 / halfHeight
            
            if bbox1[0] < bbox1[1]:
                if pt[1] > midY:
                    newPt = getPtOnSeg(midPt, pt1, bezmisc.pointdistance(midPt, pt1), dist3 - offs)
                else:
                    newPt = getPtOnSeg(midPt, pt2, bezmisc.pointdistance(midPt, pt2), dist3 + offs)
            else:
                if pt[1] < midY:
                    newPt = getPtOnSeg(midPt, pt1, bezmisc.pointdistance(midPt, pt1), dist3 - offs)
                else:
                    newPt = getPtOnSeg(midPt, pt2, bezmisc.pointdistance(midPt, pt2), dist3 + offs)
            
            res.append(newPt)
    elif (bbox1[2] == bbox2[2] and bbox1[3] == bbox2[3]):
        midX = skelComps[0][0]
        newPt = None
        
        if (patComps[-1][1] != comps1[-1][1] and round(patComps[-1][1], 10) == comps1[-1][1]):
            patComps[-1][1] = comps1[-1][1]
        
        for pt in patComps:
            pt1 = getPtsByY(pt, comps1, False)
            pt2 = getPtsByY(pt, comps2, False)
            midPt = getMidPoint(pt1, pt2)
            
            dist1 = abs(pt[0] - midX)
            dist2 = bezmisc.pointdistance(midPt, pt1) * ampl
            dist3 = dist2 * dist1 / halfHeight
            
            if bbox1[2] < bbox1[3]:
                if pt[0] < midX:
                    newPt = getPtOnSeg(midPt, pt1, bezmisc.pointdistance(midPt, pt1), dist3 - offs)
                else:
                    newPt = getPtOnSeg(midPt, pt2, bezmisc.pointdistance(midPt, pt2), dist3 + offs)
            else:
                if pt[1] > midX:
                    newPt = getPtOnSeg(midPt, pt1, bezmisc.pointdistance(midPt, pt1), dist3 - offs)
                else:
                    newPt = getPtOnSeg(midPt, pt2, bezmisc.pointdistance(midPt, pt2), dist3 + offs)
            
            res.append(newPt)
    
    return res
Пример #20
0
			return hpgl
		
		#poly = hpgl.parse(hpgl)
		
		last = ['PU',[0,0]] # start position 
		cur = [hpgl[0][:2],map(int,hpgl[0][2:].split(','))]
		i = 1
		while i < len(hpgl):
			cmd = hpgl[i][:2]
			point = map(int,hpgl[i][2:].split(','))
			next = [cmd,point]
			if not last[1] == cur[1] and not cur[1] == next[1]:
				theta = angleBetween(cur[1],last[1],next[1]) 
				if theta < math.pi/1.1:
					# start point
					dist = bezmisc.pointdistance(last[1],cur[1])
					t = d/dist+1
					start = bezmisc.tpoint(last[1],cur[1],t)
					# end point
					dist = bezmisc.pointdistance(cur[1],next[1])
					t = (4*d)/dist
					end = bezmisc.tpoint(cur[1],next[1],t)
					if t<=1:
						# go distance d past actual point 
						hpgl[i-1]='%s%d,%d'%(cur[0],start[0],start[1])
					
						# curve to end point 
						#for pt in arcto(d,0,end,start):
						#	hpgl.insert(i,'%s%d,%d'%(cur[0],pt[0],pt[1]))
						#	i+=1