геометрия - Найти центр и радиус описанной вокруг треугольника окружности

Question

Найти центр и радиус описанной вокруг треугольника окружности, если $%A (-1, -1)$%, $%B (0, 0)$%, $%C (5, 3)$%.

knop 19.0k●2●26 · Accepted Answer

1

Жестоко же для таких задач программы писать...

План. Пусть центр $%O$% имеет координаты $%(x,y)$%. Пишем уравнения $%OA=OB$% и $%OB=OC$%. Из этих уравнений находим $%x$% и $%y$%, а уже потом вычисляем $%R=OB$%.

Исполнение плана. $$ (x+1)^2+(y+1)^2=x^2+y^2 $$ $$ (x-5)^2+(y-3)^2 = x^2+y^2 $$ Упрощаем: $% 2x+2y + 2=0$%, $% -10x-6y+34=0$%. Отсюда $%x+y=-1$%, $%5x+3y=17$%. Решая, получаем $%x=10$%, $%y=-11$%. Следовательно, $%R^2=100+121$%, $%R=\sqrt{221}$%.

ссылка

отвечен 14 Июл '15 12:46

knop
19.0k●2●26

изменен 15 Июл '15 21:39

Виталина
99●1●7

Vitaly Lysanov -5●2 · Answer 2

Решение с использованием макросов Компаса и функций 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)

геометрия - Найти центр и радиус описанной вокруг треугольника окружности

2 ответа

Решение с использованием макросов Компаса и функций Python

Здравствуйте

Связанные исследования

Связанные вопросы

Отслеживать вопрос