Beispiel #1
0
	def _curveToOne(self, pt1, pt2, pt3):
		hits = splitCubic(self.currentPt, pt1, pt2, pt3, self.value, self.isHorizontal)
		for i in range(len(hits)-1):
			# a number of intersections is possible. Just take the 
			# last point of each segment.
			if not self.contourIndex in self.hits:
				self.hits[self.contourIndex] = []
			if self.isHorizontal:
				self.hits[self.contourIndex].append(round(hits[i][-1][0], 4))
			else:
				self.hits[self.contourIndex].append(round(hits[i][-1][1], 4))
		if self.isHorizontal and pt3[1] == self.value:
			# it could happen
			if not self.contourIndex in self.hits:
				self.hits[self.contourIndex] = []
			self.hits[self.contourIndex].append(pt3[0])
		if (not self.isHorizontal) and (pt3[0] == self.value):
			# it could happen
			if not self.contourIndex in self.hits:
				self.hits[self.contourIndex] = []
			self.hits[self.contourIndex].append(pt3[1])
		self.currentPt = pt3
Beispiel #2
0
	def _curveToOne(self, pt1, pt2, pt3):
		hits = splitCubic(self.currentPt, pt1, pt2, pt3, self.value, self.isHorizontal)
		for i in range(len(hits)-1):
			# a number of intersections is possible. Just take the 
			# last point of each segment.
			if not self.contourIndex in self.hits:
				self.hits[self.contourIndex] = []
			if self.isHorizontal:
				self.hits[self.contourIndex].append(round(hits[i][-1][0], 4))
			else:
				self.hits[self.contourIndex].append(round(hits[i][-1][1], 4))
		if self.isHorizontal and pt3[1] == self.value:
			# it could happen
			if not self.contourIndex in self.hits:
				self.hits[self.contourIndex] = []
			self.hits[self.contourIndex].append(pt3[0])
		if (not self.isHorizontal) and (pt3[0] == self.value):
			# it could happen
			if not self.contourIndex in self.hits:
				self.hits[self.contourIndex] = []
			self.hits[self.contourIndex].append(pt3[1])
		self.currentPt = pt3
Beispiel #3
0
def drawing_h():
    
    # Calling glyph
    font = CurrentFont ()
    glyph = font['h']
    glyph.clear()
    
    
    ## Variabili Locali [n]
    # Innesti
    x_inc_upp_h = (raccordoUpp_eff)
    y_inc_upp_h = -(raccordoUpp_eff * 2 / inn_eff)
    # Espansione
    exp_h = exp_eff * nor_eff
    # Larghezza
    wdt_h = exp_h * xht_eff
    # Monilineatià (per neutralizzare la monolinearità a valori alti)
    mon_h=tools.lin(mon_eff,1,1,0.01,0.2)
    # Monilineatià 2 (relazione fra punto medio esterno sinistro e monolinearità
    mon_h2=tools.lin(mon_h,1,mon_h/2,0.01,mon_h)
    # Correzioni otticch sqe_lft/sqe_rgt/sqi_lft/sqi_rgt
    opt_sqe_lft_h=1#.95
    opt_sqe_rgt_h=1#tools.lin(sqe_eff,1,1,0.54,1.5)
    opt_sqi_lft_h=1
    opt_sqi_rgt_h=1#tools.lin(sqi_eff,1,1,0.54,1)
    # Rientro punto medio esterno sinistro
    rtr_extLft_h=mon_h2 * tsv_eff
    #disallineamento punto centale superiore ƒ(wgt,mon,exp)
    delta_dis_h_wgt=tools.lin(wgt_nom,0.01,0,0.45,0.04)
    delta_dis_h_mon=tools.lin(mon_nom,0.01,0,1,0.02)
    delta_h=delta_dis_h_wgt+delta_dis_h_mon
    dis_h=delta_h * xht_eff
    #innalzamento innesti (#inn_eff=ƒ(mon_h , wgt , exp)
    inc_lft_ex = inn_eff * xht_eff
    inc_rgt_ex = inn_eff * xht_eff
    inc_lft_in = inn_eff * xht_eff
    inc_rgt_in = inn_eff * xht_eff

    tch_h = mon_h * tcv_eff


    ### UpperLeft
    ## punti di ancoraggio
    
    #ext
    pnt_1 = (dis_h) , (xht_eff+ovs_eff)
    hnd_1 = (dis_h + ((-wdt_h/2 - tcv_eff/2 + rtr_extLft_h) * sqe_eff * opt_sqe_lft_h)) , (xht_eff + ovs_eff)
    hnd_2 = (-wdt_h/2 + tsv_eff/2 - rtr_extLft_h - x_inc_upp_h) , ((xht_eff/2) + ((xht_eff/2 + ovs_eff) * sqe_eff))
    pnt_2 = (-wdt_h/2 + tsv_eff/2 - rtr_extLft_h - x_inc_upp_h) , (xht_eff/2  + y_inc_upp_h)
    #int
    pnt_3 = (-wdt_h/2 + tsv_eff/2 - x_inc_upp_h) , (xht_eff/2  + y_inc_upp_h)
    hnd_3 = (-wdt_h/2+tsv_eff/2 - x_inc_upp_h) , ((xht_eff/2) + ((xht_eff/2 + ovs_eff - tch_h) * sqi_eff))
    hnd_4 = ((-wdt_h/2+tcv_eff/2) * sqi_eff * opt_sqi_lft_h) , (xht_eff + ovs_eff - tch_h)
    pnt_4 = 0 , (xht_eff + ovs_eff - tch_h)

    ### Cut
    # Punti di ancoraggio
    interUpExt = (-wdt_h/2 + tsv_eff/2) , (xht_eff) 
    interUpInt = (-wdt_h/2 + tsv_eff/2) , 0
    cExt = splitCubic (pnt_1,hnd_1,hnd_2,pnt_2,interUpExt[0],False)
    cInt = splitCubic (pnt_3,hnd_3,hnd_4,pnt_4,interUpInt[0],False)
    
    #ext
    pnt_1 = ((cExt [0])[0])
    pnt_2 = ((cExt [0])[3]) 
    hnd_1 = ((cExt [0])[1])
    hnd_2 = ((cExt [0])[2])
    #int
    pnt_3 = ((cInt [1])[0])
    pnt_4 = ((cInt [1])[3])
    hnd_3 = ((cInt [1])[1])  
    hnd_4 = ((cInt [1])[2])
    

    # Disegno
    tools.genericQuarter(glyph,
                  (pnt_1),
                  (hnd_1), (hnd_2), (pnt_2),
                  (pnt_3),
                  (hnd_3), (hnd_4), (pnt_4))
    

    ### StemLeft
    ## punti di ancoraggio
    
    pnt_1 = (-wdt_h/2 + tsv_eff/2) , (xht_eff + asc_eff)
    pnt_2 = (-wdt_h/2 - tsv_eff/2) , (xht_eff + asc_eff)
    pnt_3 = (-wdt_h/2 - tsv_eff/2) , 0
    pnt_4 = (-wdt_h/2 + tsv_eff/2) , 0
                                          
    points_list = [(pnt_1) , (pnt_2) , (pnt_3) , (pnt_4)]

    #disegno
    tools.drawPolyByPoints(glyph, points_list)
 

    ### UpperRight
    ## punti di ancoraggio
    
    #ext
    pnt_1 = (wdt_h/2+tsv_eff/2) , (inc_rgt_ex)
    hnd_1 = wdt_h/2+tsv_eff/2 , (inc_rgt_ex + ((xht_eff + ovs_eff - inc_rgt_ex) * sqe_eff))
    hnd_2 = (dis_h + ((wdt_h/2 + tcv_eff/2 - rtr_extLft_h) * sqe_eff * opt_sqe_rgt_h)) , (xht_eff + ovs_eff)
    pnt_2 = (dis_h) , (xht_eff + ovs_eff)
    #int
    pnt_3 =  0 , (xht_eff + ovs_eff - tch_h)
    hnd_3 = ((wdt_h/2 - tcv_eff/2) * sqi_eff * opt_sqi_rgt_h) , (xht_eff + ovs_eff - tch_h)
    hnd_4 = (wdt_h/2 - tsv_eff/2) , (inc_rgt_in + ((xht_eff + ovs_eff - tch_h - inc_rgt_in) * sqi_eff))
    pnt_4 = (wdt_h/2-tsv_eff/2) , (inc_rgt_in)
    
    # Disegno
    tools.genericQuarter(glyph,
                  (pnt_1),
                  (hnd_1), (hnd_2), (pnt_2),
                  (pnt_3),
                  (hnd_3), (hnd_4), (pnt_4))
                                          
    ### StemRight
    ## punti di ancoraggio
    
    pnt_1 = (wdt_h/2 + tsv_eff/2) , (inc_rgt_ex)
    pnt_2 = (wdt_h/2 - tsv_eff/2) , (inc_rgt_in)
    pnt_3 = (wdt_h/2 - tsv_eff/2) , 0
    pnt_4 = (wdt_h/2 + tsv_eff/2) , 0
                                      
    points_list = [(pnt_1) , (pnt_2) , (pnt_3) , (pnt_4)]

    #disegno
    tools.drawPolyByPoints(glyph, points_list)
    
    glyph.leftMargin = mrgStm_eff 
    glyph.rightMargin = mrgCrv_eff
    
    return glyph
Beispiel #4
0
def drawing_c():
    
    # Calling glyph
    font = CurrentFont ()
    glyph = font['c']
    glyph.clear()
    
    # To show cutting shape or the cutting glyph set the on-off switchs 'on'
    showCuttingShape = off
    cut = on
    
    ## Variabili Locali [c]
    #Larghezza
    wdt_c = exp_eff * xht_eff
    # Monolinearità
    mon_c = tools.lin(mon_eff,1,1,0.01,0.2)
    # Spessore Curve Orizzontali
    tch_c = tcv_eff * mon_c
    # Raccordo
    x_inc_upp_c = (raccordoUpp_eff)
    y_inc_upp_c = -(raccordoUpp_eff * 2 / inn_eff)

    x_inc_dwn_c = (raccordoDwn_eff)
    y_inc_dwn_c = -(raccordoDwn_eff * 2 / inn_eff)
    # Disallineamento
    delta_dis_c_wgt = tools.lin(wgt_eff,0.1,0,0.45,0.04)
    delta_dis_c_mon = tools.lin(mon_eff,0.01,0,1,0.02)
    dis_c = (delta_dis_c_wgt + delta_dis_c_mon) * xht_eff
    #spessore curva verticale destra
    deltaCurva_c = tools.lin(mon_eff,0.1,0.1,1,1)
    tcv_effRgt_c = tsv_eff * deltaCurva_c
    
    ### Cutting shape
    ## punti di ancoraggio
    gap_upp_c = 0.3
    dst_upp_c = 0.2
    inn_upp_c = 0.2

    gap_dwn_c = 0.35
    dst_dwn_c = 0.1 
    inn_dwn_c = 0.2

    dstCttShape_upp_c = (dst_upp_c * xht_eff)
    gapCttShape_upp_c = (gap_upp_c * xht_eff)
    innCttShape_upp_c = (inn_upp_c * xht_eff)

    dstCttShape_dwn_c = (dst_dwn_c * xht_eff)
    gapCttShape_dwn_c = (gap_dwn_c * xht_eff)
    innCttShape_dwn_c = (inn_dwn_c * xht_eff)

    if showCuttingShape == True:
        pnt_1 = gapCttShape_upp_c , (xht_eff + ovs_eff)
        pnt_2 = dstCttShape_upp_c , (xht_eff/2 + innCttShape_upp_c)
        pnt_4 = gapCttShape_dwn_c , (-ovs_eff)
        pnt_3 = dstCttShape_dwn_c , (xht_eff/2 - innCttShape_dwn_c)
                                         
        points_list = [(pnt_4) , (pnt_3) , (pnt_2) , (pnt_1)]

        #disegno
        tools.drawPolyByPoints(glyph, points_list)

    
    ### UpperLeft
    ## punti di ancoraggio
    
    #ext
    pnt_1 = (dis_c) , (xht_eff + ovs_eff)
    hnd_1 = (dis_c + ((-wdt_c/2 - tcv_eff/2 - dis_c) * sqe_eff)) , (xht_eff + ovs_eff)
    hnd_2 = (-wdt_c/2 - tcv_eff/2) , ((xht_eff/2) + ((+xht_eff/2 + ovs_eff) * sqe_eff))
    pnt_2 = (-wdt_c/2 - tcv_eff/2) , (xht_eff/2)
    
    #int
    pnt_3 = (-wdt_c/2 + tcv_eff/2) , (xht_eff/2)
    hnd_3 = (-wdt_c/2 + tcv_eff/2) , ((xht_eff/2) + ((xht_eff/2 + ovs_eff - tch_c) * sqi_eff))
    hnd_4 = ((-wdt_c/2 + tcv_eff/2) * sqi_eff) , (xht_eff - tch_c + ovs_eff)
    pnt_4 = 0 , (xht_eff - tch_c + ovs_eff)

    # Disegno
    tools.genericQuarter(glyph,
                  (pnt_1),
                  (hnd_1), (hnd_2), (pnt_2),
                  (pnt_3),
                  (hnd_3), (hnd_4), (pnt_4))
              
    ### BottomLeft
    ## punti di ancoraggio
    
    #ext
    pnt_1 = (-wdt_c/2 - tcv_eff/2) , (xht_eff/2)
    hnd_1 = (-wdt_c/2 - tcv_eff/2) , ((xht_eff/2) + ((-xht_eff/2 - ovs_eff) * sqe_eff))
    hnd_2 = ((dis_c) + ((-wdt_c/2 - tcv_eff/2 - dis_c) * sqe_eff)) , (-ovs_eff)
    pnt_2 = (dis_c) , (-ovs_eff)
    
    #int
    pnt_3 = 0 , (tch_c - ovs_eff)
    hnd_3 = (((-wdt_c/2 + tcv_eff/2) * sqi_eff)) , (tch_c - ovs_eff)
    hnd_4 = (-wdt_c/2 + tcv_eff/2) , ((xht_eff/2) + ((-xht_eff/2 - ovs_eff + tch_c) * sqi_eff))
    pnt_4 =  (-wdt_c/2 + tcv_eff/2) , (xht_eff/2)

    # Disegno
    tools.genericQuarter(glyph,
                  (pnt_1),
                  (hnd_1), (hnd_2), (pnt_2),
                  (pnt_3),
                  (hnd_3), (hnd_4), (pnt_4))
              
    ### BottomRight
    ## punti di ancoraggio
    
    #ext
    pnt_1 = (dis_c) , (-ovs_eff)
    hnd_1 = (dis_c + ((wdt_c/2 + tcv_effRgt_c/2 - dis_c) * sqe_eff)) , (-ovs_eff)
    hnd_2 = (wdt_c/2 + tcv_effRgt_c/2 + x_inc_dwn_c) , ((xht_eff/2) + ((-xht_eff/2 - ovs_eff) * sqe_eff))
    pnt_2 = (wdt_c/2 + tcv_effRgt_c/2 + x_inc_dwn_c) , (xht_eff/2 - y_inc_dwn_c)
    
    #int
    pnt_3 = (wdt_c/2 - tcv_effRgt_c/2 + x_inc_dwn_c) , (xht_eff/2 - y_inc_dwn_c)
    hnd_3 = (wdt_c/2 - tcv_effRgt_c/2 + x_inc_dwn_c) , ((xht_eff/2) + ((-xht_eff/2 - ovs_eff + tch_c) * sqi_eff))
    hnd_4 = (((wdt_c/2 - tcv_effRgt_c/2) * sqi_eff)) , (+tch_c - ovs_eff)
    pnt_4 = 0 , (tch_c - ovs_eff)
    
    if cut == True:
        cutUp1 = (gapCttShape_dwn_c) , (- ovs_eff)
        cutUp2 = (dstCttShape_dwn_c) , (xht_eff/2 - innCttShape_dwn_c)
        
        interUpExt = bezTool.calc_int_bez ( [cutUp1,cutUp2,cutUp1,cutUp2] ,[pnt_1,hnd_1,hnd_2,pnt_2]  )
        interUpInt = bezTool.calc_int_bez ( [cutUp1,cutUp2,cutUp1,cutUp2] ,[pnt_3,hnd_3,hnd_4,pnt_4]  )
        #interUpExt = (dis_m) , (xht_eff) 
        #interUpInt = (-wdtSpn_dx_m/2 + tsv_eff/2)+wdtSpn_dx_m , 0
        
        cExt = splitCubic (pnt_1,hnd_1,hnd_2,pnt_2,interUpExt[0],False)
        cInt = splitCubic (pnt_3,hnd_3,hnd_4,pnt_4,interUpInt[0],False)
        #ext
        pnt_1 = ((cExt [0])[0])
        pnt_2 = ((cExt [0])[3]) 
        hnd_1 = ((cExt [0])[1])
        hnd_2 = ((cExt [0])[2])
            
        #int
        pnt_3 = ((cInt [1])[0])
        pnt_4 = ((cInt [1])[3])
        hnd_3 = ((cInt [1])[1])  
        hnd_4 = ((cInt [1])[2])
    else:
        pass
    
    # Disegno
    tools.genericQuarter(glyph,
                  (pnt_1),
                  (hnd_1), (hnd_2), (pnt_2),
                  (pnt_3),
                  (hnd_3), (hnd_4), (pnt_4))
              
    ### UpperRight
    ## punti di ancoraggio
    
    #ext
    pnt_1 = (wdt_c/2 + tcv_effRgt_c/2 + x_inc_upp_c) , (xht_eff/2 + y_inc_upp_c)
    hnd_1 = (wdt_c/2 + tcv_effRgt_c/2 + x_inc_upp_c) , ((xht_eff/2) + ((xht_eff/2 + ovs_eff) * sqe_eff))
    hnd_2 = ((dis_c) + ((wdt_c/2 + tcv_effRgt_c/2 - dis_c) * sqe_eff)) , ( xht_eff + ovs_eff)
    pnt_2 = (dis_c) , (xht_eff + ovs_eff)
    
    #int
    pnt_3 = 0 , (xht_eff - tch_c + ovs_eff)
    hnd_3 = (((wdt_c/2 - tcv_effRgt_c/2) * sqi_eff)) , (xht_eff - tch_c + ovs_eff)
    hnd_4 = (wdt_c/2 - tcv_effRgt_c/2 + x_inc_upp_c) , ((xht_eff/2) + ((xht_eff/2 + ovs_eff - tch_c) * sqi_eff))
    pnt_4 = (wdt_c/2 - tcv_effRgt_c/2 + x_inc_upp_c) , (xht_eff/2 + y_inc_upp_c)
    
    if cut == True:
        cutUp1 = (gapCttShape_upp_c) , (xht_eff + ovs_eff)
        cutUp2 = (dstCttShape_upp_c) , (xht_eff/2 + innCttShape_upp_c)
        
        interUpExt = bezTool.calc_int_bez ( [cutUp1,cutUp2,cutUp1,cutUp2] ,[pnt_1,hnd_1,hnd_2,pnt_2]  )
        interUpInt = bezTool.calc_int_bez ( [cutUp1,cutUp2,cutUp1,cutUp2] ,[pnt_3,hnd_3,hnd_4,pnt_4]  )
        #interUpExt = (dis_m) , (xht_eff) 
        #interUpInt = (-wdtSpn_dx_m/2 + tsv_eff/2)+wdtSpn_dx_m , 0
        
        cExt = splitCubic (pnt_1,hnd_1,hnd_2,pnt_2,interUpExt[0],False)
        cInt = splitCubic (pnt_3,hnd_3,hnd_4,pnt_4,interUpInt[0],False)
        #ext
        pnt_1 = ((cExt [1])[0])
        pnt_2 = ((cExt [1])[3]) 
        hnd_1 = ((cExt [1])[1])
        hnd_2 = ((cExt [1])[2])
            
        #int
        pnt_3 = ((cInt [0])[0])
        pnt_4 = ((cInt [0])[3])
        hnd_3 = ((cInt [0])[1])  
        hnd_4 = ((cInt [0])[2])
    else:
        pass
    

    # Disegno
    tools.genericQuarter(glyph,
                  (pnt_1),
                  (hnd_1), (hnd_2), (pnt_2),
                  (pnt_3),
                  (hnd_3), (hnd_4), (pnt_4))
        
    glyph.leftMargin = mrgCrv_eff 
    glyph.rightMargin = mrgCrv_eff
    
    return glyph
Beispiel #5
0
def drawing_q():
    
    # Calling glyph
    font = CurrentFont ()
    glyph = font['q']
    glyph.clear()
    
    
    ## Variabili locali [p]
    # Larghezza
    wdtLft_q = (2 * exp_eff / (nor_eff + 1)) * xht_eff
    wdtRgt_q = (exp_eff * nor_eff) * xht_eff
    # Innesti
    x_inc_upp_q = (raccordoUpp_eff)
    y_inc_upp_q = -(raccordoUpp_eff * 2 / inn_eff)

    x_inc_dwn_q = (raccordoDwn_eff)    
    y_inc_dwn_q = -(raccordoDwn_eff * 2 / inn_eff)
    # Squadrature specifiche sqe/sqi
    delta_sqe_nor_q = tools.lin(nor_nom,1,0,0.75,0.3*(1-gsq_nom))
    sqeRgt_q = sqe_eff + delta_sqe_nor_q
    sqeLft_q = sqe_eff - delta_sqe_nor_q
    
    delta_sqi_nor_q = tools.lin(nor_nom,1,0,0.75,0.3*(1-gsq_nom))
    sqiRgt_q = sqi_eff + delta_sqi_nor_q
    sqiLft_q = sqi_eff - delta_sqi_nor_q
    # correzioni ottiche sqe
    optSqe_upperLeft = 1# tools.lin(sqe_eff,1,1,0.54,1.3)
    optSqe_bottomLeft = 1# tools.lin(sqe_eff,1,1,0.54,1.35)
    optSqe_upperRight = 1# tools.lin(sqe_eff,1,1,0.54,1)
    optSqe_bottomRight = 1# optSqe_upperRight
    # correzioni ottiche sqi
    optSqi_upperLeft = 1# tools.lin(sqi_eff,1,1,0.54,2.18)
    optSqi_bottomLeft = 1# optSqe_upperLeft
    optSqi_upperRight = 1# tools.lin(sqi_eff,1,1,0.54,1)
    optSqi_bottomRight = 1# tools.lin(sqi_eff,1,1,0.54,1.225)
    # Monilineatià (per neutralizzare la monolinearità a valori alti)
    mon_q = tools.lin(mon_eff,1,1,0.01,0.2)
    # Monilineatià 2 (relazione fra punto medio esterno sinistro e monolinearità
    mon_q2 = tools.lin(mon_q,1,mon_q/2,0.01,mon_q)
    # Disallineamento orizzontale p ƒ(wgt,mon,exp)
    delta_dis_q_wgt = tools.lin(wgt_eff,0.1,0,0.45,0.04)
    delta_dis_q_mon = tools.lin(mon_eff,0.01,0,1,0.02)
    dis_q = (delta_dis_q_wgt + delta_dis_q_mon) * xht_eff
    # Spessore curve orizzontali
    tch_q = tcv_eff * mon_q
    # Rientro punto medio esterno sinistro
    rtr_extLft_q = mon_q2 * tsv_eff
    
    
    ### UpperLeft
    ## punti di ancoraggio
    
    #ext
    pnt_1 = -(dis_q) , (xht_eff + ovs_eff)
    hnd_1 = -((-wdtLft_q/2 - tcv_eff/2 + rtr_extLft_q + dis_q)*sqeLft_q * optSqe_upperLeft) , (xht_eff + ovs_eff)
    hnd_2 = -(-wdtLft_q/2 + tcv_eff/2 - rtr_extLft_q - x_inc_upp_q) , ((xht_eff/2) + ((xht_eff/2+ovs_eff)*sqeLft_q))
    pnt_2 = -(-wdtLft_q/2 + tcv_eff/2 - rtr_extLft_q - x_inc_upp_q) , (xht_eff/2  + y_inc_upp_q)
    #int
    pnt_3 = -(-wdtLft_q/2 + tcv_eff/2 - x_inc_upp_q) , (xht_eff/2 + y_inc_upp_q)
    hnd_3 = -(-wdtLft_q/2 + tcv_eff/2 - x_inc_upp_q) , ((xht_eff/2) + (xht_eff/2 - ovs_eff - tch_q) * sqiLft_q)
    hnd_4 = -((-wdtLft_q/2 + tcv_eff/2) * sqiLft_q * optSqi_upperLeft) , (xht_eff + ovs_eff - tch_q)
    pnt_4 = 0 , (xht_eff + ovs_eff - tch_q)
    
    ### Cut
    # Punti di ancoraggio
    interUpExt = -(-wdtLft_q/2 - tsv_eff/2) , xht_eff 
    interUpInt = -(-wdtLft_q/2 + tsv_eff/2) , -dsc_eff
    cExt = splitCubic (pnt_1,hnd_1,hnd_2,pnt_2,interUpExt[0],False)
    cInt = splitCubic (pnt_3,hnd_3,hnd_4,pnt_4,interUpInt[0],False)
    
    #ext
    pnt_1 = ((cExt [0])[0])
    pnt_2 = ((cExt [0])[3]) 
    hnd_1 = ((cExt [0])[1])
    hnd_2 = ((cExt [0])[2])
    #int
    pnt_3 = ((cInt [1])[0])
    pnt_4 = ((cInt [1])[3])
    hnd_3 = ((cInt [1])[1])  
    hnd_4 = ((cInt [1])[2])
    
    # Disegno
    tools.genericQuarter(glyph,
                  (pnt_1),
                  (hnd_1), (hnd_2), (pnt_2),
                  (pnt_3),
                  (hnd_3), (hnd_4), (pnt_4))
    

    ### StemLeft
    ## punti di ancoraggio
    
    pnt_1 = -(-wdtLft_q/2 + tsv_eff/2 - dstSpr_eff - gapSpr_eff) , xht_eff
    pnt_2 = -(-wdtLft_q/2 - tsv_eff/2) , xht_eff
    pnt_3 = -(-wdtLft_q/2 - tsv_eff/2) , -dsc_eff                                      
    pnt_4 = -(-wdtLft_q/2 + tsv_eff/2) , -dsc_eff
    pnt_5 = -(-wdtLft_q/2 + tsv_eff/2) , (xht_eff - innSpr_eff)
    pnt_6 = -(-wdtLft_q/2 + tsv_eff/2 - dstSpr_eff) , (xht_eff - innSpr_eff)

    points_list = [(pnt_1) , (pnt_2) , (pnt_3) , (pnt_4) , (pnt_5) , (pnt_6)]

    #disegno
    tools.drawPolyByPoints(glyph, points_list)


    ### BottomLeft
    ## punti di ancoraggio
    
    #ext
    pnt_1 = -(-wdtLft_q/2 + tcv_eff/2 - rtr_extLft_q - x_inc_dwn_q) , (xht_eff/2  - y_inc_dwn_q)
    hnd_1 = -(-wdtLft_q/2 + tcv_eff/2 - rtr_extLft_q - x_inc_dwn_q) , ((xht_eff/2) + ((-xht_eff/2-ovs_eff) * sqeLft_q))
    hnd_2 = -((-wdtLft_q/2 - tcv_eff/2 + rtr_extLft_q + dis_q) * sqeLft_q * optSqe_bottomLeft) , (-ovs_eff) #(dis_q) + 
    pnt_2 = -(dis_q) , (-ovs_eff)
    
    #int
    pnt_3 = 0 , (tch_q - ovs_eff)
    hnd_3 = -((-wdtLft_q/2 + tcv_eff/2) * sqiLft_q * optSqi_bottomLeft) , (tch_q - ovs_eff)
    hnd_4 = -(-wdtLft_q/2 + tcv_eff/2 - x_inc_dwn_q) , ((xht_eff/2) + ((-xht_eff/2 + ovs_eff + tch_q) * sqiLft_q))
    pnt_4 = -(-wdtLft_q/2 + tcv_eff/2 - x_inc_dwn_q) , (xht_eff/2 - y_inc_dwn_q)

    ### cut
    # Punti di ancoraggio
    interUpExt = -(-wdtLft_q/2 + tsv_eff/2) , xht_eff 
    interUpInt = -(-wdtLft_q/2 + tsv_eff/2) , -dsc_eff
    cExt = splitCubic (pnt_1,hnd_1,hnd_2,pnt_2,interUpExt[0],False)
    cInt = splitCubic (pnt_3,hnd_3,hnd_4,pnt_4,interUpInt[0],False)
    
    #ext
    pnt_1 = ((cExt [1])[0])
    pnt_2 = ((cExt [1])[3]) 
    hnd_1 = ((cExt [1])[1])
    hnd_2 = ((cExt [1])[2])
        
    #int
    pnt_3 = ((cInt [0])[0])
    pnt_4 = ((cInt [0])[3])
    hnd_3 = ((cInt [0])[1])  
    hnd_4 = ((cInt [0])[2])
    
    # Disegno
    tools.genericQuarter(glyph,
                  (pnt_1),
                  (hnd_1), (hnd_2), (pnt_2),
                  (pnt_3),
                  (hnd_3), (hnd_4), (pnt_4))
              
    ### BottomRight
    ## punti di ancoraggio
    
    #ext
    pnt_1 = -(dis_q) , (-ovs_eff)
    hnd_1 = -((wdtRgt_q/2 + tcv_eff/2 - dis_q) * sqeRgt_q * optSqe_bottomRight) , (-ovs_eff)
    hnd_2 = -(wdtRgt_q/2 + tcv_eff/2) , ((xht_eff/2) + (-xht_eff/2 - ovs_eff) *sqeRgt_q)
    pnt_2 = -(wdtRgt_q/2 + tcv_eff/2) , (xht_eff/2)
    
    #int
    pnt_3 = -(wdtRgt_q/2 - tcv_eff/2) , (xht_eff/2)
    hnd_3 = -(wdtRgt_q/2 - tcv_eff/2) , ((xht_eff/2) + (-xht_eff/2 + ovs_eff + tch_q) *sqiRgt_q)
    hnd_4 = -((wdtRgt_q/2 - tcv_eff/2 - dis_q) * sqiRgt_q * optSqi_bottomRight) , (tch_q - ovs_eff)
    pnt_4 = 0 , (tch_q - ovs_eff)

    # Disegno
    tools.genericQuarter(glyph,
                  (pnt_1),
                  (hnd_1), (hnd_2), (pnt_2),
                  (pnt_3),
                  (hnd_3), (hnd_4), (pnt_4))
              
    ### UpperRight
    ## punti di ancoraggio
    
    #ext
    pnt_1 = -(wdtRgt_q/2 + tcv_eff/2) , (xht_eff/2)
    hnd_1 = -(wdtRgt_q/2 + tcv_eff/2) , ((xht_eff/2) + (xht_eff/2 - ovs_eff) * sqeRgt_q )
    hnd_2 = -((wdtRgt_q/2 + tcv_eff/2 - dis_q) * sqeRgt_q * optSqe_upperRight) , (xht_eff + ovs_eff) #(dis_q) + 
    pnt_2 = -(dis_q) , (xht_eff + ovs_eff)
    
    #int
    pnt_3 = 0 , (xht_eff + ovs_eff - tch_q)
    hnd_3 = -((wdtRgt_q/2 - tcv_eff/2 - dis_q) * sqiRgt_q * optSqi_upperRight) , (xht_eff + ovs_eff - tch_q)
    hnd_4 = -(wdtRgt_q/2 - tcv_eff/2) , ((xht_eff/2) + (xht_eff/2 - ovs_eff - tch_q) * sqiRgt_q)
    pnt_4 = -(wdtRgt_q/2 - tcv_eff/2) , (xht_eff/2)

    # Disegno
    tools.genericQuarter(glyph,
                  (pnt_1),
                  (hnd_1), (hnd_2), (pnt_2),
                  (pnt_3),
                  (hnd_3), (hnd_4), (pnt_4))

    glyph.leftMargin = mrgCrv_eff 
    glyph.rightMargin = mrgStm_eff
    return glyph
Beispiel #6
0
    pnt_1 = (dis_m) , (xht_eff+ovs_eff)
    hnd_1 = (dis_m + ((-wdtSpn_sx_m/2 - tcv_eff/2 + rtr_extLft_m) * sqe_eff * opt_sqe_lft_m)) , (xht_eff + ovs_eff)
    hnd_2 = (-wdtSpn_sx_m/2 + tsv_eff/2 - rtr_extLft_m - x_inc_upp_m) , ((xht_eff/2) + ((xht_eff/2 + ovs_eff) * sqe_eff))
    pnt_2 = (-wdtSpn_sx_m/2 + tsv_eff/2 - rtr_extLft_m - x_inc_upp_m) , (xht_eff/2  + y_inc_upp_m)
   
    #int
    pnt_3 = (-wdtSpn_sx_m/2 + tsv_eff/2 - x_inc_upp_m) , (xht_eff/2  + y_inc_upp_m)
    hnd_3 = (-wdtSpn_sx_m/2+tsv_eff/2 - x_inc_upp_m) , ((xht_eff/2) + ((xht_eff/2 + ovs_eff - tch_m) * sqi_eff))
    hnd_4 = ((-wdtSpn_sx_m/2+tcv_eff/2) * sqi_eff * opt_sqi_lft_m) , (xht_eff + ovs_eff - tch_m)
    pnt_4 = 0 , (xht_eff + ovs_eff - tch_m)

    ### cut
    # Punti di ancoraggio
    interUpExt = (-wdtSpn_sx_m/2 - tsv_eff/2) , (xht_eff) 
    interUpInt = (-wdtSpn_sx_m/2 + tsv_eff/2) , 0
    cExt = splitCubic (pnt_1,hnd_1,hnd_2,pnt_2,interUpExt[0],False)
    cInt = splitCubic (pnt_3,hnd_3,hnd_4,pnt_4,interUpInt[0],False)
   
    #ext
    pnt_1 = ((cExt [0])[0])
    pnt_2 = ((cExt [0])[3]) 
    hnd_1 = ((cExt [0])[1])
    hnd_2 = ((cExt [0])[2])
       
    #int
    pnt_3 = ((cInt [1])[0])
    pnt_4 = ((cInt [1])[3])
    hnd_3 = ((cInt [1])[1])  
    hnd_4 = ((cInt [1])[2])