Решение с использованием макросов Компаса и функций Python
Применение Компаса при решении школьных геометрических задач, проверяется соответственно на школьных задачах.
Освоение макросов Компаса позволит полноценно работать конструктором.
Первоначальная программа состоит из операторов;
otrezok (a,b) # чертит отрезок, ставит точки и буквы возле точек,
abs=(a+b)/2 # находит середину отрезка
и аналогичных,
а также функций с названиями обеспечивающими смысловой понимание.
tp=peresechenie_otrezkov (a,b,c,d)
tp=peresechenie_prjmish (a,ugol,c,ugol)
......
Ссылка на рисунок:
https://yadi.sk/i/kZjLz7YHhtoXU
Изображение получено на код:
a=100+80*1j
b=200+150*1j
c=190+300*1j
tp=okr_vokrug_treugolnika (a,b,c)
print tp
tochka_imj_ev (tp,"tp",5)
tekst(tp-300*1j,tp.real)
tekst(tp-300,tp.imag)
tochka_imj_ev (tp,"tp",5)
tochka_imj_ev (tp.real+0*1j,"tp",6)
tochka_imj_ev (0+tp.imag*1j,"tp",6)
Здесь оформление графики и вызов функции Python
okr_vokrug_treugolnika (a,b,c)
которая приведена ниже:
def okr_vokrug_treugolnika (a,b,c):
print a,b,c
tochka_imj_ev (a,"a",5)
tochka_imj_ev (b,"b",5)
tochka_imj_ev (c,"c",5)
otrezok (a,b)
otrezok (a,c)
otrezok (b,c)
abs=(a+b)/2
acs=(a+c)/2
tochka_imj_ev (abs,"abs",3)
tochka_imj_ev (acs,"acs",3)
ug_ab=ugol_otrezka (a,b)
ug_ac=ugol_otrezka (a,c)
ug_ab_90=ug_ab+math.pi/2
ug_ac_90=ug_ac+math.pi/2
prjmaj (abs,ug_ab)
prjmaj (acs,ug_ac)
prjmaj (abs,ug_ab_90)
prjmaj (acs,ug_ac_90)
tp=peresechrnie_prjmich (abs,acs,ug_ab_90,ug_ac_90)
tochka_imj_ev (tp,"tp",0)
prjmaj (tp,0)
prjmaj (tp,math.pi/2)
return tp
В функции для облегчения восприятия применяются комплексные числа.
Вычисляются середины отрезков, проводятся перпендикуляры и находится точка их пересечения.
В качестве общих замечаний и отвечая на естественные вопросы могу сказать:
Комплексные числа обеспечивают наглядность близкую к школьной геометрии.
Компас это почти стандарт для конструирования.
Язык Python принят для макросов Компаса.
Графика 2D это основа для 3d моделей.
http://forum.ascon.ru/index.php?topic=28124.0
Получается что прямой путь открыт.
Ниже приведен полный код макроса Компаса с функциями:
#unicode_var.encode('cp1251')
import math
import cmath
import Kompas10API5 as KAPI
import Kompas10API7 as KAPI7
import pythoncom
from win32com.client import Dispatch
import LDefin2D
import LDefin3D
import ksConstants as CONST2D7
import ksConstants3D as CONST3D7
import MiscellaneousHelpers as MH
try:
Kompas
print "yes Kompas:"
except Exception:
print "no Kompas:"
import Kompas6API5, LDefin3D, LDefin2D
Kompas, doc3d = start3d()
iKompasObject = Dispatch('KOMPAS.Application.5')
iKompasObject = KAPI.KompasObject(iKompasObject)
MH.iKompasObject = iKompasObject
iApplication = Dispatch('KOMPAS.Application.7')
iApplication = KAPI7.IApplication(iApplication)
MH.iApplication = iApplication
iDocument2D = iKompasObject.Document2D()
iDocumentParam = KAPI.ksDocumentParam(iKompasObject.GetParamStruct(LDefin2D.ko_DocumentParam))
iDocumentParam.Init()
iDocumentParam.type = LDefin2D.lt_DocFragment
iDocument2D.ksCreateDocument(iDocumentParam)
# massivi uglov prjmich
ugol_prjmoj=[]
ugol_prjmoj_2=[]
# massiv prjmich
spisok=[]
spisok_2=[]
spisok_3=[]
spisok_3=0
spisok_3=[]
rezult=[]
nom_spis=0
nom_spis_3=0
nom_spis_3=0
shag=300
diametr=2100
shir_stup=1500
kolich_prjmich_stupenej=5
visota_stupeni=70
tolchina_materiala=4
zazor_m_s=visota_stupeni-tolchina_materiala
razmah_gor=diametr+shir_stup/2
# stupenki s 5 uglov
ug90_1=math.pi/4-0.1
ug90_2=math.pi*3/4
# Kolichestvo zabegnich celoe chetnoe
kolich_zabegnich=math.floor(0.5*math.pi*diametr/shag)
shag=0.5*math.pi*diametr/kolich_zabegnich
#+++++++++++++++++++++++++++++++++++++++++++++++++++++++____________________________________________________________________________________________
def ugol_otrezka(a,b):
ug1=(cmath.polar(b-a)[1])
return ug1
def tochka(a,nomer):
x=a.real
y=a.imag
iDocument2D.ksPoint(x, y, nomer)
def tochka_imj(a,nomer):
x=a.real
y=a.imag
def bar(var):
for k, v in globals().items():
if id(var) == id(a):
# print a,v
if a==v:
rez=k
return rez
rez= bar (a)
iDocument2D.ksPoint(x, y, nomer)
tekst (a+7+22*1j,rez)
def otrezok_na_rast(a,b,c,d,rast):
### na rasstojnii b peresechenie so storonami ###
ugol_ab=ugol_otrezka(a,b)
ugol_ac=ugol_otrezka(a,c)
t90_a=a-rast*math.sin(ugol_ab)+rast*math.cos(ugol_ab)*1j
ugol_treug=ugol_ac-(ugol_ab+math.pi/2)
dlina_dobavki=rast*math.tan(ugol_treug)
a_rast=t90_a-dlina_dobavki*math.cos(ugol_ab)-dlina_dobavki*math.sin(ugol_ab)*1j
tochka (a_rast)
return a_rast
def prjmaj(koor=0+0*1j,ugol=0):
x1=1.0*koor.real
y1=1.0*koor.imag
iDocument2D.ksLine(x1, y1, math.degrees(ugol))
def otrezok(a,b,oboznachenie=False):
""" """
x1=1.0*a.real
y1=1.0*a.imag
x2=1.0*b.real
y2=1.0*b.imag
#If Doc.ksExistObj(L12)=1 then Doc.ksDeleteObj(L12);
#IApplication::ExecuteKompasCommand( ksCMEditClear, FALSE|TRUE )?
obj1 = iDocument2D.ksLineSeg(x1,y1,x2,y2, 1)
obj2 = iDocument2D.ksLineSeg(x1+111,y1,x2+111,y2, 2)
iDocument2D.ksDeleteObj(obj2)
if oboznachenie== True:
tochka_imj (a,5)
tochka_imj (b,5)
ttt=100+100*1j
iii("ttt",7)
else:
a=a
def mnogitel_povorota (ugol):
ugoltmp=math.radians(ugol)
jjj=math.sqrt(1.0-math.sin(ugoltmp)*math.sin(ugoltmp))
mn_nov=jjj+math.sin(ugoltmp)*1j
return mn_nov
def massiv_po_okrug (koor_tochka1,koor_tochka2,ugol,kolich,centr):
# a1=koor_tochka1-centr
# b1=koor_tochka2-centr
ugoltmp=math.radians(ugol)
jjj=math.sqrt(1.0-math.sin(ugoltmp)*math.sin(ugoltmp))
mn_nov=jjj+math.sin(ugoltmp)*1j
print "mn_nov =", mn_nov
a11=koor_tochka1-centr
b11=koor_tochka2-centr
otrezok (a11+centr,b11+centr)
# prjmaj (koor=a1+sm,ugol=ugol_otrezka(a1+sm,b1+sm))
print "smf=",sm
for nom in iter(range(kolich)):
a22=(a11)*(mn_nov)
b22=(b11)*(mn_nov)
# s=abs((a11+b11)/2-(a22+b22)/2)
a11=a22
b11=b22
otrezok (a22+centr,b22+centr)
prjmaj (koor=a22+centr,ugol=ugol_otrezka(a22+centr,b22+centr))
spisok_3.append(a22+centr)
spisok_3.append(b22+centr)
spisok_3.append("\n")
rezult =[]
rezult.append(a22+sm)
rezult.append(b22+sm)
return rezult
def massiv_po_okrug_obj (koor_tochka1,koor_tochka2,ugol,kolich):
a1=koor_tochka1
b1=koor_tochka2
ugoltmp=math.radians(ugol)
jjj=math.sqrt(1.0-math.sin(ugoltmp)*math.sin(ugoltmp))
mn_nov=jjj+math.sin(ugoltmp)*1j
a11=a1
b11=b1
otrezok (a1+sm,b1+sm)
# prjmaj (koor=a1+sm,ugol=ugol_otrezka(a1+sm,b1+sm))
for nom in iter(range(kolich)):
a22=(a11)*(mn_nov)
b22=(b11)*(mn_nov)
s=abs((a11+b11)/2-(a22+b22)/2)
a11=a22
b11=b22
otrezok (a22+sm,b22+sm)
# prjmaj (koor=a22+sm,ugol=ugol_otrezka(a22+sm,b22+sm))
spisok_3.append(a22+sm)
spisok_3.append(b22+sm)
spisok_3.append("\n")
rezult =[]
rezult.append(a22+sm)
rezult.append(b22+sm)
return rezult
def na_rast_paral (kolich,a1,b1,s111):
ug=ugol_otrezka (a1,b1)
for nom in iter(range(kolich)):
ap=a1+(nom+1)*s111*math.cos(ug-math.pi/2)+(nom+1)*s111*math.sin(ug-math.pi/2)*1j
bp=b1+(nom+1)*s111*math.cos(ug-math.pi/2)+(nom+1)*s111*math.sin(ug-math.pi/2)*1j
otrezok(ap,bp)
spisok_3.append(ap)
spisok_3.append(bp)
spisok_3.append("\n")
def na_rast_paral_bezl (kolich,a1,b1,s222):
global ap
global bp
ug=ugol_otrezka (a1,b1)
ap=a1+s222*math.cos(ug-math.pi/2)+s222*math.sin(ug-math.pi/2)*1j
bp=b1+s222*math.cos(ug-math.pi/2)+s222*math.sin(ug-math.pi/2)*1j
def tekst(k,inf):
x=k.real
y=k.imag
iParagraphParam = KAPI.ksParagraphParam(iKompasObject.GetParamStruct(LDefin2D.ko_ParagraphParam))
iParagraphParam.Init()
iParagraphParam.x = x
iParagraphParam.y = y
iParagraphParam.ang = 0.0
iParagraphParam.height = 7.13581323623
iParagraphParam.width = 10.55124855041
iParagraphParam.hFormat = 0
iParagraphParam.vFormat = 0
iParagraphParam.style = 1
iDocument2D.ksParagraph(iParagraphParam)
iTextLineParam = KAPI.ksTextLineParam(iKompasObject.GetParamStruct(LDefin2D.ko_TextLineParam))
iTextLineParam.Init()
iTextLineParam.style = 1
iTextItemArray = KAPI.ksDynamicArray(iKompasObject.GetDynamicArray(4))
iTextItemParam = KAPI.ksTextItemParam(iKompasObject.GetParamStruct(LDefin2D.ko_TextItemParam))
iTextItemParam.Init()
iTextItemParam.iSNumb = 0
iTextItemParam.s = inf
iTextItemParam.type = 0
iTextItemFontParam = KAPI.ksTextItemFont(iTextItemParam.GetItemFont())
iTextItemFontParam.Init()
iTextItemFontParam.bitVector = 4096
iTextItemFontParam.color = 0
iTextItemFontParam.fontName = "GOST type A"
iTextItemFontParam.height = 20.0
iTextItemFontParam.ksu = 1.0
iTextItemArray.ksAddArrayItem(-1, iTextItemParam)
iTextLineParam.SetTextItemArr(iTextItemArray)
iDocument2D.ksTextLine(iTextLineParam)
obj = iDocument2D.ksEndObj()
#formula='x+1'
##print eval(formula)
##def ftochka_imj(tp,nomer):
## print a,b,c,d
## print "tp,noner=",tp,nomer
## vizov="tochka_imj_ev("+tp+",\""+tp+"\","+"nomer)"
### global c
## print "vizov=",vizov
## eval(vizov)
def tochka_imj_ev(tp,im,nomer):
# print "dan isp=",tp,im,nomer
# eval(funkk)
tochka (tp,nomer)
tekst (tp+7+22*1j,im)
def tochka_imj_eva(tp,funkk):
print tp,funkk
eval(funkk)
# tochka (tp,nomer)
tekst (tp,"rez")
def iii(im,nomer):
print "im,nomer",im,nomer
def peresechrnie_otrezkov(a,b,c,d,oboznachenie=False):
""" a,b,c,d -koordinati obo=False - bez imeni tochki """
otrezok (a,b)
otrezok (c,d)
ug_ba=((cmath.polar((b-a))[1]))
ug_dc=((cmath.polar((d-c))[1]))
ug_ba_tan=math.tan(ug_ba)
ug_dc_tan=math.tan(ug_dc)
k1=ug_ba_tan
k2=ug_dc_tan
# po osi y otsekaet
b1=a.imag-k1*a.real
b2=c.imag-k2*c.real
bb1=a-(a)*k1
xtp=(b2-b1)/(k1-k2)
ytp=k1*xtp + b1
tp=xtp+ytp*1j
##x = 22222
##
##formula='x+1'
##print eval(formula)
# tochka_imj_eva("tp",7)
# funk='tochka (tp,3)'
# eval(funk)
# tochka (tp,3)
# tp1=tp
##################################### tochka_imj_eva (tp,"tochka (tp,7)")
if oboznachenie== True:
# tochka_imj_ev (tp,"tp",7)
tochka (tp,7)
tochka_imj (a,5)
tochka_imj (b,5)
tochka_imj (c,5)
tochka_imj (d,5)
# tochka_imj (a,5)
# tochka_imj (b,5)
# tochka_imj (c,5)
# tochka_imj (d,5)
ttt=100+100*1j
iii("ttt",7)
else:
a=a
# tochka (tp,7)
# tochka (a,5)
# tochka (b,5)
# tochka (c,5)
# tochka (d,5)
a1=1863.5491+ 1512.5341*1.0j
b1=3109.8835+2252.2591*1.0j
# Programma Programma Programma Programma Programma Programma Programma Programma
# Programma Programma Programma Programma Programma Programma Programma Programma
# Programma Programma Programma Programma Programma Programma Programma Programma
# Programma Programma Programma Programma Programma Programma Programma Programma
# Programma Programma Programma Programma Programma Programma Programma Programma
# Programma Programma Programma Programma Programma Programma Programma Programma
# Programma Programma Programma Programma Programma Programma Programma Programma
def dlina_dugi(a,b,ugol_d):
v=1/0
otrezok (a,b)
c=(a+b)/2
tochka_imj (a,5)
tochka_imj (b,5)
tochka_imj_ev (c,"c",2)
ugol_ab=(cmath.polar(b-a)[1])
dlina_ac=0.5*abs(b-a)
dlina_cd=dlina_ac/math.tan(ugol_d/2)
ugol_ac_ad=(math.pi)/2-(ugol_d)/2
ugol_ad=-ugol_ac_ad+ugol_ab
radius=dlina_ac/math.sin(ugol_d/2)
d=a+radius*math.cos(ugol_ad)+radius*math.sin(ugol_ad)*1j
# d=c+dlina_cd*math.cos(ugol_ab-0.5*math.pi)+dlina_cd*math.sin(ugol_ab-0.5*math.pi)*1j
tochka_imj_ev(d,"d",8)
otrezok (a,d)
otrezok (b,d)
otrezok (c,d)
obj = iDocument2D.ksCircle(d.real,d.imag, radius, 2)
obj = iDocument2D.ksArcByPoint(d.real,d.imag, radius, a.real, a.imag, b.real,b.imag, -1, 1)
dlina_dugi=radius*ugol_d
return dlina_dugi
#11111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111
def dlina_dugi_1(a,b,ugol_d):
global c
global d
# f2.write(str(nom))
# f2.write("\t\t\t")
# f3.write(str(nom))
# f3.write("\t\t\t")
otrezok (a,b)
c=(a+b)/2
graf.append ((a-a).real)
f3.write(str(int((a-a).real)))
f3.write("\t")
graf.append ((b-a).real)
f3.write(str(int((b-a).real)))
f3.write("\t\t")
graf.append (ugol_d)
f3.write(str(int(100*ugol_d)))
f3.write("\t\t")
# ftochka_imj("a",5)
# ftochka_imj("b",5)
# ftochka_imj("c",5)
tochka_imj_ev (a,"a",5)
tochka_imj_ev (b,"b",5)
tochka_imj_ev (c,"c",2)
ugol_ab=(cmath.polar(b-a)[1])
dlina_ac=0.5*abs(b-a)
dlina_cd=dlina_ac/math.tan(ugol_d/2)
# ugol_ac_ad=(math.pi)/2-(ugol_d)/2
# ugol_ad=-ugol_ac_ad+ugol_ab
radius=dlina_ac/math.sin(ugol_d/2)
# d=a+radius*math.cos(ugol_ad)+radius*math.sin(ugol_ad)*1j
d=c+dlina_cd*math.cos(ugol_ab-0.5*math.pi)+dlina_cd*math.sin(ugol_ab-0.5*math.pi)*1j
print "d/c=",d/c
# ftochka_imj("d",5)
# tochka_imj_ev(d,"d",8)
otrezok (a,d)
otrezok (b,d)
otrezok (c,d)
obj = iDocument2D.ksCircle(d.real,d.imag, radius, 2)
obj = iDocument2D.ksArcByPoint(d.real,d.imag, radius, a.real, a.imag, b.real,b.imag, -1, 1)
dlina_dugi=radius*ugol_d
graf.append (d-a)
graf.append ("\n")
f3.write(str(int((d-a).real)))
f3.write("\t")
f3.write(str(int((d-a).imag)))
f3.write("\t\t")
print
# print d/b
tmp=1000*d/b
tmpr=tmp.real
tmpi=tmp.imag
tmpr=int(tmpr)
tmpi=int(tmpi)
f3.write(str(tmpr))
f3.write("\t")
f3.write(str(tmpi))
f3.write("\t")
f3.write(str(int(math.sqrt(tmpr*tmpr+tmpi*tmpi))))
f3.write("\t")
f3.write("\n\n")
print tmpr,tmpi
return dlina_dugi
def peresechrnie_prjmich(a,b,ug_a,ug_b,oboznachenie=False):
""" a,b -koordinati ug_a,ug_b -ugli obo=False - bez imeni tochki """
ug_a_tan=math.tan(ug_a)
ug_b_tan=math.tan(ug_b)
k1=ug_a_tan
k2=ug_b_tan
# po osi y otsekaet
b1=a.imag-k1*a.real
b2=b.imag-k2*b.real
tochka_imj_ev (0+b1*1j,"b1",0)
tochka_imj_ev (0+b2*1j,"b2",0)
prjmaj (0+0*1j,math.pi/2)
prjmaj (0+0*1j,0)
xtp=(b2-b1)/(k1-k2)
ytp=k1*xtp + b1
tp=xtp+ytp*1j
return tp
def okr_vokrug_treugolnika (a,b,c):
print a,b,c
tochka_imj_ev (a,"a",5)
tochka_imj_ev (b,"b",5)
tochka_imj_ev (c,"c",5)
otrezok (a,b)
otrezok (a,c)
otrezok (b,c)
abs=(a+b)/2
acs=(a+c)/2
tochka_imj_ev (abs,"abs",3)
tochka_imj_ev (acs,"acs",3)
ug_ab=ugol_otrezka (a,b)
ug_ac=ugol_otrezka (a,c)
ug_ab_90=ug_ab+math.pi/2
ug_ac_90=ug_ac+math.pi/2
prjmaj (abs,ug_ab)
prjmaj (acs,ug_ac)
prjmaj (abs,ug_ab_90)
prjmaj (acs,ug_ac_90)
tp=peresechrnie_prjmich (abs,acs,ug_ab_90,ug_ac_90)
tochka_imj_ev (tp,"tp",0)
prjmaj (tp,0)
prjmaj (tp,math.pi/2)
return tp
#ooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooo
a=100+80*1j
b=200+150*1j
c=190+300*1j
tp=okr_vokrug_treugolnika (a,b,c)
print tp
tochka_imj_ev (tp,"tp",5)
tekst(tp-300*1j,tp.real)
tekst(tp-300,tp.imag)
tochka_imj_ev (tp,"tp",5)
tochka_imj_ev (tp.real+0*1j,"tp",6)
tochka_imj_ev (0+tp.imag*1j,"tp",6)
Найдите угловой коэффициент прямой $%AB$%, центр отрезка $%AB$%, затем уравнение серединного перпендикуляра к $%AB$%. Далее находим уравнение ещё одного серединного перпендикуляра, их точка пересечения даст центр описанной вокруг треугольника окружности.