Алгоритм Брезенхэма

@leetoo · Регистрация: 10.01.2013

Author24 — интернет-сервис помощи студентам

У кого есть программа, которая реализует алгоритм Брезенхема

@leetoo · 10.01.2013, 22:13 **[ТС]**

Catstail, Помогите с реализацией алгоритма Брезенхема плиз

@Catstail · 10.01.2013, 22:15

Я уже написал - чуть позже (но сегодня).

@leetoo · 10.01.2013, 23:08 **[ТС]**

_sg, Здравствуйте, можете помочь с реализацией алгоритма Брезенхема?

@_sg · 10.01.2013, 23:18

сложно для меня

@leetoo · 10.01.2013, 23:21 **[ТС]**

_sg, А можете например без алгоритма, написать такую программу, которая бы например рисовала треугольник и закрашивала его кругами???

@Lambdik · 10.01.2013, 23:32

http://rosettacode.org/wiki/Bi... ommon_Lisp

@_sg · 10.01.2013, 23:37

Вам нужен тот кто разбирается в AutoLisp, HomeLisp или Racket, поиском по форуму найдите кто решал такие задачи.

Добавлено через 1 минуту
VH, Catstail ...

@_sg · 10.01.2013, 23:40

на память:

Lisp

(defun draw-line (buffer x1 y1 x2 y2 pixel)
  (declare (type rgb-pixel-buffer buffer))
  (declare (type integer x1 y1 x2 y2))
  (declare (type rgb-pixel pixel))
  (let* ((dist-x (abs (- x1 x2)))
     (dist-y (abs (- y1 y2)))
     (steep (> dist-y dist-x)))
    (when steep
      (psetf x1 y1 y1 x1
         x2 y2 y2 x2))
    (when (> x1 x2)
      (psetf x1 x2 x2 x1
         y1 y2 y2 y1))
    (let* ((delta-x (- x2 x1))
       (delta-y (abs (- y1 y2)))
       (error (floor delta-x 2))
       (y-step (if (< y1 y2) 1 -1))
       (y y1))
      (loop 
     :for x :upfrom x1 :to x2
     :do (progn (if steep 
            (setf (rgb-pixel buffer x y) pixel)
            (setf (rgb-pixel buffer y x) pixel))
            (setf error (- error delta-y))
            (when (< error 0)
              (incf y y-step)
              (incf error delta-x)))))
    buffer))

@leetoo · 10.01.2013, 23:47 **[ТС]**

_sg, слушай еще один такой вопрос, а как эту прогу запустить, просто мы на под Autocad пишем на лиспе

Добавлено через 4 минуты
Lambdik, А вы можете мне помочь перевести это на AutoLisp? Спасибо за ссылку

@_sg · 10.01.2013, 23:48

Lisp

1	сначала ее нужно переписать на AutoLisp

@leetoo · 10.01.2013, 23:48 **[ТС]**

Catstail, Я снова к Вам за помощью, по поводу алгоритма Брезенхема, а вы под AutoCad пишите?

@leetoo · 10.01.2013, 23:56 **[ТС]**

_sg, оооо, жесть, только как, вы мне не поможите?

@Catstail · 11.01.2013, 00:16

Вот ординарный перевод алгоритма Брэзенхема из Википедии на HomeLisp:

Lisp

;; w - окно; (x,y)-координаты
 
(Defun Bresenham (w x0 x1 y0 y1) 
  (let* ((deltax (abs (- x1 x0)))
         (deltay (abs (- y1 y0)))
         (err    0)
         (deltaerr deltay)  
         (y y0)
         (x 0))
        (dotimes (i (+ 1 (- x1 x0)) t)
          (grwPset w (+ x0 i) y _BLACK)
          (setq err (+ err deltaerr))     
          (when (>= (* 2 err) deltax)
                (setq y (sub1 y))
                (setq err (- err deltax))))))
 
==> Bresenham 
 
(defun test nil
  (grwCreate 'w 200 200 "Линии" _WHITE)
  (Bresenham 'w 10 150 180 20) 
  (grwShow 'w)
)
 
==> test

Вот результат:

@Catstail · 11.01.2013, 00:30

Сообщение от _sg

сложно для меня

- да ладно... Не скромничайте!

Добавлено через 2 минуты

Сообщение от leetoo

которая бы например рисовала треугольник и закрашивала его кругами??

Вот программа (HomeLisp):

Кликните здесь для просмотра всего текста

Lisp

(defun graph (w) (prog (n u z) 
 
                      (grwCreate w 600 400 "Комплексный графический тест" &HFFFFFF)
              
                      (grwShow w)
 
                      (setq z 1) 
 
                   L@ (setq z (menu w 
                                    '(" Треугольники   "
                                      "     Круги      "
                                      "    Эллипсы     "
                                      "     Точки      "
                                      "     Боксы      "
                                      "      Муар      "
                                      " Прямоугольники "
                                      "     Спирали    " 
                                      "  Цветные соты  "
                                      " Не может быть! " 
                                      )
                                    z)
                      )
 
                      (cond ((eq z 1) (setq u (triangle w)))
                            ((eq z 2) (setq u (fillcirc w)))
                            ((eq z 3) (setq u (ellipse w)))
                            ((eq z 4) (setq u (points w)))
                            ((eq z 5) (setq u (fboxes w)))
                            ((eq z 6) (setq u (muar w)))
                            ((eq z 7) (setq u (rect w)))
                            ((eq z 8) (setq u (spiral w)))
                            ((eq z 9) (setq u (honey w)))
                            ((eq z 10) (setq u (penrose w)))
                            ( T       (go E@))
                      )
 
                      (gc)
 
                      (go L@)
 
                   E@ (grwDestroy w)
                      (return u)
                 )
)    
 
//
//  Несуществующий объект
//
 
(Defun penrose (w)
 
(prog (h0 h1 h2 w0 w1 w2 clr OX OY NX NY IX IY JX JY MX MY HX HY GX GY BX BY CX CY DX DY EX EY FX FY KX KY LX LY AX AY)
 
      (grwCls w)
 
      (grwScale w -105 105 -105 105)
 
      (grwSetParm w 3 0 &HFFFFFF) 
 
      (setq clr &HCCCCCC)
 
      (setq OX 0)
 
      (setq OY 0)
 
      (setq h0 25)
  
      (setq h1 25)
 
      (setq h2 25)
 
      (setq w0 20)
 
      (setq w1 20)
 
      (setq w2 20)
 
      (setq NX (+ w0 OX))
 
      (setq NY (- OY h0))
 
      (setq IX (+ w0 OX))
 
      (setq IY (+ h0 OY)) 
 
      (setq Jx (- OX w0))
 
      (setq JY (+ h0 OY))
 
      (setq MX (- OX W0)) 
 
      (setq MY (- OY h0))
 
      (setq HX (+ W0 OX)) 
 
      (setq HY (- OY h0 h1))
 
      (setq GX (- OX w0 w1))     
 
      (setq GY (- OY h0 h1))
 
      (setq BX (- OX w0 w1))
 
      (setq BY (+ h0 h1 h2 OY))
  
      (setq CX (+ w0 w1 w2 OX))
 
      (setq CY (+ h0 h1 h2 OY))
 
      (setq DX (+ w0 w1 w2 OX))
 
      (setq DY HY) 
 
      (setq EX (+ w0 w1 OX))
 
      (setq EY (- OY h0 h1 h2))  
 
      (setq FX (- OX w0 w1 w2))
 
      (setq FY (- OY h0 h1 h2)) 
 
      (setq AX FX)
 
      (setq AY (+ OY h0 h1)) 
 
      (setq KX JX)
 
      (setq KY AY)
 
      (setq LX EX)
 
      (setq LY AY)
 
 
      (grwRect w JX JY NX NY &H000000)
 
      (grwline w AX AY BX BY &H000000)
      (grwline w BX BY CX CY &H000000)
      (grwline w CX CY DX DY &H000000)
      (grwline w EX EY FX FY &H000000)
      (grwline w FX FY AX AY &H000000)
      (grwline w DX DY EX EY &H000000)
      
      (grwFill w (+ FX 3) (+ FY 3) &HFFFF00 &H000000)
 
      (grwline w BX BY GX GY &H000000)
      (grwline w GX GY HX HY &H000000)
      (grwline w HX HY NX NY &H000000)
      (grwline w IX IY LX LY &H000000)
      
      (grwline w LX LY KX KY &H000000)
      (grwline w KX KY JX JY &H000000)
      (grwline w LX LY EX EY &H000000)
      (grwline w GX GY MX MY &H000000)
 
      (grwPrint w -45 90 "Несуществующий объект Пенроуза" &H0000FF)  
 
@Inkey 
 
      (setq k (grwInkey w))
 
      (cond ((eq k 27) (return (grwSavePic w 1 "penrose.gif"))))
 
      (go @Inkey)
 
)
 
)
 
//
//  Соты
//
 
(Defun honey (w)
 
(prog (r fi z hx hy vx vy n hxx hyy m cx cy k Om x y r g b cf)  
 
      (grwCls w) 
 
      (grwScale w -100 100 -100 100)
 
      (setq r 10)
      (setq fi (/ _pi 3))
      (setq z 8)  
 
      (setq hx (* r (sqr 3.0)))
      (setq hy 0)
 
      (setq vx (* r (sqr 3.0) (cos fi)))
 
      (setq vy (* r (sqr 3.0) (sin fi)))
 
      (for n (- 0 Z) z   
 
           ( 
 
              (setq hxx (* hx n))
              (setq hyy (* hy n))
 
              (for m (- 0 Z) z   
 
                   (
 
                       (setq vxx (* vx m))
                       (setq vyy (* vy m))
 
                       (setq cx (+ vxx hxx))
                       (setq cy (+ vyy hyy))
 
                       (setq k 0)
 
                       (setq Om (* 0.5 Fi))
 
                  L    (cond ((eq k 0) (grwPset w 
                                                (+ cx (* r (cos Om)))
                                                (+ cy (* r (sin Om)))
                                                &H000000))
                             (T        (grwLine w 
                                                (+ cx (* r (cos Om)))
                                                (+ cy (* r (sin Om)))
                                                nil nil 
                                                &H000000))
                       )
  
                       (setq k -1)                              
 
                       (setq Om (+ Om Fi))
 
                       (cond ((lessp Om (+ (* 2.0 _pi) Fi)) (Go L)))
 
                 
                   ))
 
           ))
 
     @L      
 
          (setq r (rnd 255))
          (setq g (rnd 255))
          (setq b (rnd 255))
 
          (setq cf (fix2bit (+ b (* 256 g) (* 65536 r))))
 
          (setq x (+ -100 (rnd 200)))
          (setq y (+ -100 (rnd 200)))
           
          (grwFill w x y cf &H000000) 
 
          (setq k (grwInkey w))
 
          (cond ((eq k 27) (return (grwSavePic w 1 "honey.gif"))))
        
          (go @L)
  
)
 
)
 
//
//  Спирали
//
 
(defun spiral (w) (prog (r g b c p fi ff x y k x0 y0 j)
 
                        (grwCls w)
 
                        (grwScale w -100 100 -100 100)
 
                   L0
 
                        (setq r (rnd 255))
                        (setq g (rnd 255))
                        (setq b (rnd 255))
 
                        (setq c (fix2bit (+ b (* 256 g) (* 65536 r))))
 
                        (setq x0 (- (rnd 200.0) 100))
 
                        (setq y0 (- (rnd 200.0) 100))
 
                        (setq p 0)
 
                        (setq fi 0.0)
 
                   L1
 
                        (setq k (grwInkey w))
 
                        (cond ((eq k 27) (go Ret)))
 
                        (setq FF (/ (* Fi _Pi) 180.0))  
 
                        (setq y (+ y0 (* (sin FF) FF)))
 
                        (setq x (+ x0 (* (cos FF) FF)))
 
                        (cond ((eq p 0) (grwPset w x y c))
                              (T        (grwLine w x y nil nil c))
                        )
      
                        (setq p 1) 
     
                        (setq fi (+ fi 10.0))       
 
                        (cond ((lessp fi (* 360 3)) (go L1))) 
 
                        (go L0)
 
                    Ret (gc) (return 'ok) 
 
                )
 
)
 
//
//  Рисование прямоугольников
//
 
(defun rect (w)  (prog (r g b i x y ww hh)
 
                    (grwCls w)
 
                    (grwScale w 0 100 0 100) 
 
                    (setq i 300)
 
                 L 
 
                    (setq k (grwInkey w))
 
                    (cond ((eq k 27) (go Ret)))
 
                    (setq x (rnd 100))
                    (setq y (rnd 100))
                    (setq ww (rnd 30))
                    (setq hh (rnd 30))
                    (setq r (rnd 255))
                    (setq g (rnd 255))
                    (setq b (rnd 255))
       
                    (grwRect w x y (+ x ww) (+ y hh) (fix2bit (+ b (* 256 g) (* 65536 r))))
 
                    (setq i (sub1 i))
 
                    (cond ((eq i 0) (go Ret)))
 
                    (go L)
 
                Ret (gc) 
 
                    (grwSavePic w 1 "rect.gif")
 
                    (return 'ok!)
 
 
))
 
//
//  Рисование кругов
//
 
(defun fillcirc (w) 
 
      (prog (r g b i x y ww hh c rr k)
 
            (grwScale w 0 100 0 100) 
 
            (grwCls w) 
 
            (setq i 300)
 
      L
            (setq k (grwInkey w))
            (cond ((eq k 27) (return 'ok!)))
 
            (setq x (rnd 100))
            (setq y (rnd 100))
            (setq rr (rnd 30))
            (setq r (rnd 255))
            (setq g (rnd 255))
            (setq b (rnd 255))
 
            (setq c (fix2bit (+ b (* 256 g) (* 65536 r))))
 
            (grwSetParm w 1 0 c)
       
            (grwcircle w x y rr c)
 
            (setq i (sub1 i))
 
            (cond ((eq i 0) (go Ret)))
 
            (go L)
 
       Ret
            (grwSavePic w 1 "circles.gif")
 
            (return 'ok!) 
 
     )
 
)
 
//
//  Рисование заполненных боксов
//
 
(defun fboxes (w)
 
(prog (r g b i x y ww hh k)
 
      (grwScale w 0 100 0 100) 
 
      (grwCls w)
 
      (setq i 300)
 
   L  (setq x (rnd 100))
      (setq y (rnd 100))
      (setq ww (rnd 30))
      (setq hh (rnd 30))
      (setq r (rnd 255))
      (setq g (rnd 255))
      (setq b (rnd 255))
       
      (grwFrect w x y (+ x ww) (+ y hh) (fix2bit (+ b (* 256 g) (* 65536 r))))
 
      (setq k (grwInkey w))
 
      (cond ((eq k 27) (return 'ok!)))
 
      (setq i (sub1 i))
 
      (cond ((eq i 0) (Go Ret)))
 
      (go L)
 
  Ret
      (grwSavePic w 1 "boxes.gif")
 
      (return 'ok!) 
 
)
 
)
 
//
//  Рисование эллипсов
//
 
(defun ellipse (w)
 
(prog (r g b i x y ww hh c aa k)
 
      (grwScale w 0 100 0 100) 
 
      (grwCls w)
 
      (setq i 300)
 
   L  (setq x (rnd 100))
      (setq y (rnd 100))
      (setq rr (rnd 30))
      (setq r (rnd 255))
      (setq g (rnd 255))
      (setq b (rnd 255))
      (setq aa (rnd 2.0))
 
      (cond ((lessp aa 0.001) (setq aa 0.3)))  
 
      (setq c (fix2bit (+ b (* 256 g) (* 65536 r))))
 
      (grwSetParm w 1 0 c)
       
      (grwellipse w x y rr c aa)
 
      (setq k (grwInkey w))
 
      (cond ((eq k 27) (return 'ok!)))
 
      (setq i (sub1 i))
 
      (cond ((eq i 0) (go Ret)))
 
      (go L)
 
  Ret
      (grwSavePic w 1 "ellipses.gif")
 
      (return 'ok!) 
 
))
 
//
//  Рисование цветных точек
//
 
(defun points (w)
 
(prog (r g b i x y k)
 
      (grwScale w 0 100 0 100) 
 
      (grwSetParm w 3 nil nil)
 
      (grwCls w)
 
      (setq i 800)
 
   L  (setq x (rnd 100))
      (setq y (rnd 100))
      (setq r (rnd 255))
      (setq g (rnd 255))
      (setq b (rnd 255))
       
      (grwPset w x y (fix2bit (+ b (* 256 g) (* 65536 r))))
 
      (setq k (grwInkey w))
 
      (cond ((eq k 27) (return 'ok!)))
 
      (setq i (sub1 i))
 
      (cond ((eq i 0) (go Ret)))
 
      (go L)
 
  Ret
      (grwSavePic w 1 "points.gif")
 
      (return 'ok!) 
 
 
))
 
//
//  Рисование треугольников
//
 
(defun triangle (w) 
 
(prog (x1 y1 x2 y2 x3 y3 r g b cb cf rr1 rr2 rr3 xm ym xx yy i)  
 
      (grwScale w 0 640 0 480)
 
      (grwCls w) 
 
      (setq i 0) 
 
      beg_loop
 
          (setq x1 (rnd 640))
          (setq y1 (rnd 480))
 
          (setq x2 (rnd 640))
          (setq y2 (rnd 480))
 
          (setq x3 (rnd 640))
          (setq y3 (rnd 480))
 
          (setq r (rnd 255))
          (setq g (rnd 255))
          (setq b (rnd 255))
 
          (setq cb (fix2bit (+ b (* 256 g) (* 65536 r))))
 
          (setq r (rnd 255))
          (setq g (rnd 255))
          (setq b (rnd 255))
 
          (setq cf (fix2bit (+ b (* 256 g) (* 65536 r))))
 
          (setq rr1 (sqr (+ (^ (- x1 x2) 2) (^ (- y1 y2) 2))))
          (setq rr2 (sqr (+ (^ (- x2 x3) 2) (^ (- y2 y3) 2))))
          (setq rr3 (sqr (+ (^ (- x1 x3) 2) (^ (- y1 y3) 2))))
 
          (cond ((lessp (+ rr1 rr2) rr3) (go beg_loop)))
          (cond ((lessp (+ rr1 rr3) rr2) (go beg_loop)))
          (cond ((lessp (+ rr2 rr3) rr1) (go beg_loop)))
 
          (cond ((lessp (- (+ rr1 rr2) rr3) 0.001) (go beg_loop)))
          (cond ((lessp (- (+ rr1 rr3) rr2) 0.001) (go beg_loop)))
          (cond ((lessp (- (+ rr2 rr3) rr1) 0.001) (go beg_loop)))
 
          (grwLine w x1 y1 x2 y2 cb)
 
          (grwLine w x2 y2 x3 y3 cb)
 
          (grwLine w x3 y3 x1 y1 cb)
 
          (setq xm (* 0.5 (+ x2 x3)))
          (setq ym (* 0.5 (+ y2 y3)))
 
          (setq xx (* 0.5 (+ x1 xm)))
          (setq yy (* 0.5 (+ y1 ym)))
 
          (grwFill w xx yy cf cb)
 
          (setq k (grwInkey w))
 
          (cond ((eq k 27) (return 'ok!)))
 
          (setq i (add1 i))
 
          (cond ((lessp i 100) (go beg_loop)))  
 
          (grwSavePic w 1 "triangles.gif")
 
          (return 'ok!)          
 
))
 
//
//  Рисование муара
//
 
(defun muar(w)
 
      (prog (nline wi dx qx c x1 x2 i k)
 
            (grwCls w)
 
            (grwSetParm w 1 nil nil)
 
            (grwScale w 0 640 0 480)
 
            (setq nline 213)
 
            (setq wi (/ 640.0 3.0))
 
            (setq dx (/ Wi nline))
 
            (setq qx (/ 640.0 nline))
 
       L0   (setq r (rnd 255))
            (setq g (rnd 255))
            (setq b (rnd 255))
            (setq c (fix2bit (+ b (* 256 g) (* 65536 r))))
      
            (setq i 1) 
 
       L1
 
            (setq k (grwInkey w))
 
            (cond ((eq k 27) (go Ret)))
 
            (setq x1 (+ Wi (* dx (- i 1))))
 
            (setq x2 (* qx (- i 1)))
 
            (grwLine w x1 1 x2 479 c)     
 
            (grwLine w x1 479 x2 1 c)     
 
            (setq i (add1 i))      
 
            (cond ((lessp i nline) (go L1)))
 
            (go L0)
 
       Ret
            (gc) 
 
            (grwSavePic w 1 "muar.gif")
 
            (return 'ok!) 
 
))
 
 
//
//   Дать n-й элемент массива
//
 
(defun item (array index) (prog (i c tmp)
                                (setq i 1)
                                (setq tmp array)
                          @L    (setq c (car tmp))
                                (cond ((eq i index) (return c)))
                                (setq i (add1 i))
                                (setq tmp (cdr tmp))
                                (go @L)
                          )
)          
 
//
//  Гафическое меню
//
 
(defun menu (w mnu nn)
 
       (prog (ww hh x y a n sz color)
 
             (setq sz (length mnu))
 
             (grwSetParm w 2 1 &HFFFFFF) 
 
             (grwScale w -150 150 -150 150)
 
             (grwCls w)
 
             (grwFont w "FIXEDSYS" 12 T nil)
                      
             (setq hh (grwTextH w (item mnu 1)))
 
             (setq ww (grwTextW w (item mnu 1)))
 
             (setq x (+ -150 (* (- 300 ww) 0.5)))
 
             (setq y (* 0.5 sz hh))
 
             // Рисуем начальное положение
 
             ;;(for j 1 sz
             
             //(dotimes (j sz nil) 
 
             (for j 1 sz
 
                    (
 
                     (setq color (cond ((eq j nn) &HFF0000)
                                       (T         &H000000)
                                 )
                      )
 
                     (grwPrint w x (- y  (* (- j 1) hh))  (item mnu j) color)
 
                    )                  
              )
 
             // Обработка клавиатурного ввода 
 
             (setq n nn)
 
             (setq a (prog (k)
 
              @Inkey (setq k (grwInkey w))
 
                     (cond ((eq k 27) (return 0)))
 
                     (cond ((eq k 13) (return n)))
 
                     (cond ((eq k 38) (prog nil (setq n (sub1 n)) (cond ((eq n 0) (setq n sz))))))
 
                     (cond ((eq k 40) (prog nil (setq n (add1 n)) (cond ((eq n (add1 sz)) (setq n 1))))))
 
                     (cond ((eq k 0)(go @inkey)))
 
                     // Рисуем текущее положение
 
                     (for j 1 sz
             
                          (
                             (setq color (cond ((eq j n) &HFF0000)
                                               (T        &H000000)
                                         )
                             )
 
                             (grwPrint w x (- y  (* (- j 1) hh))  (item mnu j) color)                      
 
                          )
                     )
 
                     (go @Inkey)
 
                  )
 
             )
 
             (return a)
                
       )
 
)
 
;;
 
(main)
 
(gc)

@Catstail · 11.01.2013, 00:40

А вот картинки, построенные этой программой:

@leetoo 0 / 0 / 0 Регистрация: 10.01.2013 Сообщений: 11
		1
	Алгоритм Брезенхэма 10.01.2013, 21:58. Показов 1195. Ответов 15 Метки нет (Все метки) У кого есть программа, которая реализует алгоритм Брезенхема 0

@leetoo 0 / 0 / 0 Регистрация: 10.01.2013 Сообщений: 11
	10.01.2013, 22:13 [ТС]	2
	Catstail, Помогите с реализацией алгоритма Брезенхема плиз 0

@Catstail Модератор 36601 / 20330 / 4220 Регистрация: 12.02.2012 Сообщений: 33,640 Записей в блоге: 13
	10.01.2013, 22:15	3
	Я уже написал - чуть позже (но сегодня). 0

@leetoo 0 / 0 / 0 Регистрация: 10.01.2013 Сообщений: 11
	10.01.2013, 23:08 [ТС]	4
	_sg, Здравствуйте, можете помочь с реализацией алгоритма Брезенхема? 0

@_sg 4699 / 4394 / 380 Регистрация: 12.05.2012 Сообщений: 3,096
	10.01.2013, 23:18	5
	сложно для меня 0

@leetoo 0 / 0 / 0 Регистрация: 10.01.2013 Сообщений: 11
	10.01.2013, 23:21 [ТС]	6
	_sg, А можете например без алгоритма, написать такую программу, которая бы например рисовала треугольник и закрашивала его кругами??? 0

@Lambdik 1050 / 944 / 107 Регистрация: 04.11.2012 Сообщений: 974 Записей в блоге: 3
	10.01.2013, 23:32	7
	http://rosettacode.org/wiki/Bi... ommon_Lisp 0

@_sg 4699 / 4394 / 380 Регистрация: 12.05.2012 Сообщений: 3,096
	10.01.2013, 23:37	8
	Вам нужен тот кто разбирается в AutoLisp, HomeLisp или Racket, поиском по форуму найдите кто решал такие задачи. Добавлено через 1 минуту VH, Catstail ... 0

@leetoo 0 / 0 / 0 Регистрация: 10.01.2013 Сообщений: 11
	10.01.2013, 23:47 [ТС]	10
	_sg, слушай еще один такой вопрос, а как эту прогу запустить, просто мы на под Autocad пишем на лиспе Добавлено через 4 минуты Lambdik, А вы можете мне помочь перевести это на AutoLisp? Спасибо за ссылку 0

@leetoo 0 / 0 / 0 Регистрация: 10.01.2013 Сообщений: 11
	10.01.2013, 23:48 [ТС]	12
	Catstail, Я снова к Вам за помощью, по поводу алгоритма Брезенхема, а вы под AutoCad пишите? 0

	11.01.2013, 00:40

@leetoo 0 / 0 / 0 Регистрация: 10.01.2013 Сообщений: 11
	10.01.2013, 23:56 [ТС]	13
	_sg, оооо, жесть, только как, вы мне не поможите? 0