Anubis / Anubis

 *Project*                                  Anubis
   
 *Title*                        Geometrical figures for images
   
 *Copyright*                     Copyright (c) Alain Prouté 2002. 

 *Released*

 *Author*       Olivier Duvernois


   
   *Overview*   
   
   
   Outils de dessin de figures géométriques dans une image.
   


   *** (1) Draw line 
   *** (2) Draw filled curve line
   *** (3) Draw circle
   *** (4) Draw disk
   *** (5) Draw ellipse
   *** (6) Filles ellipse
   *** (7) Draw triangle
   *** (8) Draw filled triangle
   *** (9) Draw empty rectangle 
   *** (10) Tests


   
   
   
   *** (1) Draw line 

   Any filled line : 
   
public define One
   draw_line
     (
       RGBAImage      img,
       RGBA           color,     // line color
       (Int,Int)  point0,
       (Int,Int)  point1
     ).

   
   Any line with particular look :
   
public type LineLook:
   no_line,
   filled,
   dotted  (Int,     // nb of pixels draw
            Int).    // nb of 'blanks' between 2 sequences of drawing
   

 public define One
   draw_line
     (
       RGBAImage      img,
       RGBA           color,     // line color
       (Int,Int)  point0,
       (Int,Int)  point1,
       LineLook       llook
     ).


   
   Horizontal line : 
   
public define One
   draw_H_line
     (
       RGBAImage  img,
       RGBA       color,
       Int      x1,
       Int      x2,
       Int      y
     ).

   and : 
   
public define One
   draw_H_line
     (
       RGBAImage  img,
       RGBA       color,
       Int      x1,
       Int      x2,
       Int      y,
       LineLook   llook
     ).

   
   Vertical line : 
   
public define One
   draw_V_line
     (
       RGBAImage  img,
       RGBA       color,
       Int      y1,
       Int      y2,
       Int      x
     ).

   and 

public define One
   draw_V_line
     (
       RGBAImage  img,
       RGBA       color,
       Int      y1,
       Int      y2,
       Int      x,
       LineLook   llook
     ).

 
   The same, where graphic origin is not image origin : 
   
public define One
   draw_line
     (
       RGBAImage       img,
       RGBA            color,     // line color
       (Int,Int)   point0,
       (Int,Int)   point1,
       (Int,Int)   origin
     ).

public define One
   draw_line
     (
       RGBAImage       img,
       RGBA            color,     // line color
       (Int,Int)   point0,
       (Int,Int)   point1,
       (Int,Int)   origin,
       LineLook        llook
     ).


   
public define One
   draw_H_line
     (
       RGBAImage     img,
       RGBA          color,
       Int         x1,
       Int         x2,
       Int         y,
       (Int,Int) origin
     ).
   
public define One
   draw_H_line
     (
       RGBAImage     img,
       RGBA          color,
       Int         x1,
       Int         x2,
       Int         y,
       (Int,Int) origin,
       LineLook      llook
     ).
   
public define One
   draw_V_line
     (
       RGBAImage     img,
       RGBA          color,
       Int         y1,
       Int         y2,
       Int         x,
       (Int,Int) origin
     ).


   
   *** (2) Draw filled curve line
   
   
public define One
   draw_curve_line
     (
       RGBAImage            img,
       RGBA                 color,
       List((Int,Int))  points
     ).
   
   
   Chaque point marquant une brisure dans la ligne peut être marqué par un signe graphique : 

public type CurveMarkSize:
   small,
   medium,
   big.
   
   Cette taille se traduit en pixels par :
   
public define Int
   px_CMS
     (
       CurveMarkSize cms
     ) =
   if cms is 
     {
       small  then 2,
       medium then 3,
       big    then 5
     }.
   
   Cela signifie, si un cercle avec la taille 'big' est retenu, il sera tracé un cercle de
   5 pixels de rayon.
   
public type CurveLineMark:
   none,
   circle   (CurveMarkSize  size,
             RGBA           color),
   disk     (CurveMarkSize  size,
             RGBA           color),
   square   (CurveMarkSize  size,
             RGBA           color),
   fsquare  (CurveMarkSize  size,    // filled square
             RGBA           color),
   triangle (CurveMarkSize  size,
             RGBA           color).

   
  Pour obtenir la taille de la marque : 
   
public define Int
   size
     (
       CurveLineMark clm
     ) =
   if clm is 
     {
       none          then (Int)0,
       circle(s,c)   then px_CMS(s),
       disk(s,c)     then px_CMS(s),
       square(s,c)   then px_CMS(s),
       fsquare(s,c)  then px_CMS(s),
       triangle(s,c) then px_CMS(s),
     }.
   
   
public define One
   draw_curve_line
     (
       RGBAImage            img,
       RGBA                 color,   // line
       List((Int,Int))  points,
       LineLook             llook,
       CurveLineMark        mark
     ).
   
   
   *** (3) Draw circle
   
public define One
   draw_circle
     (
       RGBAImage   img,
       RGBA        color,
       Int       x_center,
       Int       y_center,
       Int       radius
     ).

   
   *** (4) Draw disk
   
public define One
   draw_disk
     (
       RGBAImage   img,
       RGBA        color,
       Int       x_center,
       Int       y_center,
       Int       r
     ).
   
   
   *** (5) Draw ellipse
   
   
public define One
   draw_ellipse
     (
       RGBAImage   img,
       RGBA        color,
       Int       x_center,
       Int       y_center,
       Int       a,        // length of bigger radius
       Int       b         // length of smaller radius
     ) .


   *** (6) Filled ellipse
   
public define One
   draw_filled_ellipse
     (
       RGBAImage   img,
       RGBA        color,
       Int       x_center,
       Int       y_center,
       Int       a,        // length of bigger radius
       Int       b         // length of smaller radius
     ) .

   
   
   *** (7) Draw triangle
   
public define One
   draw_triangle
     (
       RGBAImage      img,
       RGBA           color,
       (Int,Int)  summit1,
       (Int,Int)  summit2,
       (Int,Int)  summit3
     ).

   
   
   
   *** (9) Draw empty rectangle 
   
public define One
   draw_empty_rectangle
     (
       RGBAImage   img,
       RGBA        color,
       Rectangle   rect).

   
   
   *** (10) Tests
   

   Pour tester les fonctionnalités, il faut compiler le fichier test_gfigures.anubis
   

   
   
   
   --- That's all for the public part. ---------------------------------------------------

   
   
read tools/basis.anubis
read widgets4/widget.anubis
read widgets4/host_window.anubis
read widgets4/image.anubis
   
   *** [1] Draw line (line segment)
      *** [1.1] Tools
         *** [1.1.1] Dotted tools
      *** [1.2] Horizontal line
         *** [1.2.1] filled line
         *** [1.2.2] dotted line
      *** [1.3] Vertical line
         *** [1.3.1] Filled line
         *** [1.3.2] Dotted line
      *** [1.4] Any line
         *** [1.4.1] filled line
         *** [1.4.1] dotted line
   *** [2] Draw curve line
      *** [2.1] filled line without mark
      *** [2.2] dotted line with marks
   *** [3] Draw circle
   *** [4] Disk
   *** [5] Ellipse
   *** [6] Filled ellipse
   *** [7] Draw triangle
      *** [7.1] Empty triangle
      *** [7.2] Filled triangle
   *** [8] Draw empty rectangle 
  *** [9] Tests
   
   
   *** [1] Draw line (line segment)

   
      *** [1.1] Tools
   
         *** [1.1.1] Dotted tools
   
define Int -> Bool
   draw_test
     (
       Int  pxd
     ) =
   (Int i) |-> i < pxd.
   
   
define Int -> Bool
   empty_test
     (
       Int  pxe
     ) =
   (Int i) |-> i < pxe.
   
type DottedLineTest:
   draw  (Int -> Bool),  // if true, draw pixel
   empty (Int -> Bool).  // if true, do nothing


   
      *** [1.2] Horizontal line
   
   
         *** [1.2.1] filled line
   
public define One
   draw_H_line
     (
       RGBAImage  img,
       RGBA       color,
       Int      x1,
       Int      x2,
       Int      y
     ) =
   if x1 > x2 then unique
   else draw_pixel(img,x1,y,color);
        draw_H_line(img,color,x1+1,x2,y).
   
   
   
   
public define One
   draw_H_line
     (
       RGBAImage     img,
       RGBA          color,
       Int         x1,
       Int         x2,
       Int         y,
       (Int,Int) origin
     ) =
   if origin is (xo,yo) then 
   with xx1 = xo+x1,
        xx2 = xo+x2,
   if xx1 > xx2 then draw_H_line(img,color,xx2,xx1,yo-y)
                 else draw_H_line(img,color,xx1,xx2,yo-y).
   


         *** [1.2.2] dotted line
   
public define One
   draw_H_dotted_line
     (
       RGBAImage       img,
       RGBA            color,
       Int           x1,
       Int           x2,
       Int           y,
       DottedLineTest  dl_test,
       DottedLineTest  draw,
       DottedLineTest  empty,
       Int           i
     ) =
   if x1 > x2 then unique
   else if dl_test is 
          {
            draw(test)  then
              if test(i)
                then draw_pixel(img,x1,y,color);
                     draw_H_dotted_line(img,color,x1+1,x2,y,dl_test,draw,empty,i+1)
                else draw_H_dotted_line(img,color,x1+1,x2,y,empty,draw,empty,0),
            empty(test) then
              if test(i)
                then draw_H_dotted_line(img,color,x1+1,x2,y,dl_test,draw,empty,i+1)
                else draw_H_dotted_line(img,color,x1+1,x2,y,draw,draw,empty,0),
          }.
   
define One
   draw_H_dotted_line
     (
       RGBAImage  img,
       RGBA       color,
       Int      x1,
       Int      x2,
       Int      y,
       Int      pxd,   // pixels to draw
       Int      pxe    // 'empty' pixels
     ) =
   with draw = draw(draw_test(pxd)),
   draw_H_dotted_line(img,color,x1,x2,y,draw,draw,empty(empty_test(pxe)),0).

   
public define One
   draw_H_line
     (
       RGBAImage  img,
       RGBA       color,
       Int      x1,
       Int      x2,
       Int      y,
       LineLook   llook
     ) =
   if llook is 
     {
       no_line         then draw_pixel(img,x1,y,color);
                            draw_pixel(img,x2,y,color),
       filled          then draw_H_line(img,color,x1,x2,y),
       dotted(pxd,pxe) then draw_H_dotted_line(img,color,x1,x2,y,pxd,pxe)
     }.


public define One
   draw_H_line
     (
       RGBAImage     img,
       RGBA          color,
       Int         x1,
       Int         x2,
       Int         y,
       (Int,Int) origin,
       LineLook      llook
     ) =
   if llook is 
     {
       no_line           then draw_pixel(img,x1,y,color);
                              draw_pixel(img,x2,y,color),
       filled            then draw_H_line(img,color,x1,x2,y,origin),
       dotted(pxd,pxe) then 
         if origin is (xo,yo) then 
         with xx1 = xo+x1,
              xx2 = xo+x2,
          if xx1 > xx2 then draw_H_dotted_line(img,color,xx2,xx1,yo-y,pxd,pxe)
                        else draw_H_dotted_line(img,color,xx1,xx2,yo-y,pxd,pxe)
     }.
   
   
   
      *** [1.3] Vertical line
   
   
         *** [1.3.1] Filled line
   
public define One
   draw_V_line
     (
       RGBAImage       img,
       RGBA            color,
       Int           y1,
       Int           y2,
       Int           x
     ) =
   if y1 > y2 then unique
   else draw_pixel(img,x,y1,color);
        draw_V_line(img,color,y1+1,y2,x).
   
   

public define One
   draw_V_line
     (
       RGBAImage      img,
       RGBA           color,
       Int          y1,
       Int          y2,
       Int          x,
       (Int,Int)  origin
     ) =
   if origin is (xo,yo) then 
     with yy1 = yo-y1,
          yy2 = yo-y2,
     if yy1 > yy2
      then draw_V_line(img,color,yy2,yy1,xo+x)
      else draw_V_line(img,color,yy1,yy2,xo+x).

   
         *** [1.3.2] Dotted line
   
public define One
   draw_V_dotted_line
     (
       RGBAImage       img,
       RGBA            color,
       Int           y1,
       Int           y2,
       Int           x,
       DottedLineTest  dl_test,
       DottedLineTest  draw,
       DottedLineTest  empty,
       Int           i
     ) =
   if y1 > y2 then unique 
   else if dl_test is 
          {
            draw(test) then
              if test(i) 
                then draw_pixel(img,x,y1,color);
                     draw_V_dotted_line(img,color,y1+1,y2,x,dl_test,draw,empty,i+1)
                else draw_V_dotted_line(img,color,y1+1,y2,x,empty,draw,empty,0),
            empty(test) then
              if test(i) 
                then draw_V_dotted_line(img,color,y1+1,y2,x,dl_test,draw,empty,i+1)
                else draw_V_dotted_line(img,color,y1+1,y2,x,draw,draw,empty,0),
          }.
   
   
public define One
   draw_V_dotted_line
     (
       RGBAImage   img,
       RGBA        color,
       Int       y1,
       Int       y2,
       Int       x,
       Int       pxd,
       Int       pxe
     ) =
   with draw = draw(draw_test(pxd)),
   draw_V_dotted_line(img,color,y1,y2,x,draw,draw,empty(empty_test(pxe)),0).
   
   
public define One
   draw_V_line
     (
       RGBAImage   img,
       RGBA        color,
       Int       y1,
       Int       y2,
       Int       x,
       LineLook    llook
     ) =
   if llook is
     { 
       no_line         then draw_pixel(img,x,y1,color);
                            draw_pixel(img,x,y2,color),
       filled          then draw_V_line(img,color,y1,y2,x),
       dotted(pxd,pxe) then draw_V_dotted_line(img,color,y1,y2,x,pxd,pxe),
     }.
   
   
      *** [1.4] Any line
   
   http://anomaly.developpez.com/tutoriel/sdl/partie2/

   
         *** [1.4.1] filled line
   
   
define One
   bresenham_VA
     (
       RGBAImage  img,
       RGBA       color,
       Int      y,
       Int      y2,
       Int      x,
       Int      d,
       Int      xincr,
       Int      aincr,
       Int      bincr
     ) =
   if y > y2 then unique else
   if d >= 0 
     then with x_ = x+xincr,
   //print("x_="+x_+" y="+y+" \n");
          draw_pixel(img,x_,y,color);
          bresenham_VA(img,color,y+1,y2,x_,d+aincr,xincr,aincr,bincr)
     else draw_pixel(img,x,y,color);
   //print("x="+x+" y="+y+" \n");
          bresenham_VA(img,color,y+1,y2,x,d+bincr,xincr,aincr,bincr).
   
   
define One
   bresenham_VA
     (
       RGBAImage  img,
       RGBA       color,
       Int      x1,
       Int      y1,
       Int      x2,
       Int      y2
     ) =
   with xincr = (Int)(if x2 > x1 then 1 else (0-1)),
        dy = y2 - y1,
        dx = abs(x2 - x1),
        d = 2 * dx - dy,
        aincr = 2 * (dx - dy),
        bincr = 2 * dx,
        x = x1,
        y = y1,
   draw_pixel(img,x,y,color);
   bresenham_VA(img,color,y+1,y2,x,d,xincr,aincr,bincr).
   
   
define One
   bresenham_HA
     (
       RGBAImage  img,
       RGBA       color,
       Int      x,
       Int      x2,
       Int      y,
       Int      d,
       Int      yincr,
       Int      aincr,
       Int      bincr
     ) =
   if x > x2 then unique else
   if d >= 0
     then with y_ = y+yincr,
          draw_pixel(img,x,y_,color);
          bresenham_HA(img,color,x+1,x2,y_,d+aincr,yincr,aincr,bincr)
     else draw_pixel(img,x,y,color);
          bresenham_HA(img,color,x+1,x2,y,d+bincr,yincr,aincr,bincr).
   
   
define One
   bresenham_HA
     (
       RGBAImage  img,
       RGBA       color,
       Int      x1,
       Int      y1,
       Int      x2,
       Int      y2
     ) =
   //print("x1="+x1+" y1="+y1+" | x2="+x2+" y2="+y2+"\n");
   with yincr = (Int)(if y2 > y1 then 1 else (0-1)),
        dx = x2 - x1,
        dy = abs(y2 - y1),
        d = 2 * dy - dx,
        aincr = 2 * (dy - dx),
        bincr = 2 * dy,
   draw_pixel(img,x1,y1,color);
   bresenham_HA(img,color,x1+1,x2,y1,d,yincr,aincr,bincr).
   
   
public define One
   draw_line
     (
       RGBAImage       img,
       RGBA            color,
       (Int,Int)   point1,
       (Int,Int)   point2
     ) =
   if point1 is (x1,y1) then
   if point2 is (x2,y2) then
   
   if y1=y2 then 
      (if x1 < x2 then draw_H_line(img,color,x1,x2,y1)
                   else draw_H_line(img,color,x2,x1,y1)) else
   
   if x1=x2 then 
      (if y1 < y2 then draw_V_line(img,color,y1,y2,x1)
                   else draw_V_line(img,color,y2,y1,x1)) else
   
   
   if abs(x2-x1) < abs(y2-y1)
     then // vertical axis  (VA)
          if y1 > y2
            then bresenham_VA(img,color,x2,y2,x1,y1)
            else bresenham_VA(img,color,x1,y1,x2,y2)
     else // horizontal axis (HA)
          if x1 > x2
            then bresenham_HA(img,color,x2,y2,x1,y1)
            else bresenham_HA(img,color,x1,y1,x2,y2).

   
   
   
public define One
   draw_line
     (
       RGBAImage       img,
       RGBA            color,     // line color
       (Int,Int)   point1,
       (Int,Int)   point2,
       (Int,Int)   origin
     ) = 
   if point1 is (x1,y1) then 
   if point2 is (x2,y2) then 
   if origin is (xo,yo) then 
   draw_line(img,color,(xo+x1,yo-y1),(xo+x2,yo-y2)).

   
         *** [1.4.1] dotted line

define One
   bresenham_VA_dotted
     (
       RGBAImage       img,
       RGBA            color,
       Int           y,
       Int           y2,
       Int           x,
       Int           d,
       Int           xincr,
       Int           aincr,
       Int           bincr,
       DottedLineTest  dl_test,
       DottedLineTest  draw,
       DottedLineTest  empty,
       Int           i
     ) =
   if y > y2 then unique else
   if d >= 0 
     then with x_ = x+xincr,
          if dl_test is 
            {
              draw(test)  then 
                if test(i)
                  then draw_pixel(img,x_,y,color);
                       bresenham_VA_dotted(img,color,y+1,y2,x_,d+aincr,xincr,aincr,bincr,
                                           dl_test,draw,empty,i+1)
                  else bresenham_VA_dotted(img,color,y+1,y2,x_,d+aincr,xincr,aincr,bincr,
                                           empty,draw,empty,0)
              empty(test) then 
                if test(i)
                  then bresenham_VA_dotted(img,color,y+1,y2,x_,d+aincr,xincr,aincr,bincr,
                                           dl_test,draw,empty,i+1)
                  else bresenham_VA_dotted(img,color,y+1,y2,x_,d+aincr,xincr,aincr,bincr,
                                           draw,draw,empty,0)
            }
       else if dl_test is 
            {
              draw(test)  then 
                if test(i)
                  then draw_pixel(img,x,y,color);
                       bresenham_VA_dotted(img,color,y+1,y2,x,d+bincr,xincr,aincr,bincr,
                                           dl_test,draw,empty,i+1)
                  else bresenham_VA_dotted(img,color,y+1,y2,x,d+bincr,xincr,aincr,bincr,
                                           empty,draw,empty,0)

              empty(test) then 
                if test(i)
                  then bresenham_VA_dotted(img,color,y+1,y2,x,d+bincr,xincr,aincr,bincr,
                                           dl_test,draw,empty,i+1)
                  else bresenham_VA_dotted(img,color,y+1,y2,x,d+bincr,xincr,aincr,bincr,
                                           draw,draw,empty,0)
            }.
   
define One
   bresenham_VA_dotted
     (
       RGBAImage       img,
       RGBA            color,
       Int           x1,
       Int           y1,
       Int           x2,
       Int           y2,
       DottedLineTest  dl_test,
       DottedLineTest  draw,
       DottedLineTest  empty
     ) =
   with xincr = (Int)(if x2 > x1 then 1 else (0-1)),
        dy = y2 - y1,
        dx = abs(x2 - x1),
        d = 2 * dx - dy,
        aincr = 2 * (dx - dy),
        bincr = 2 * dx,
        x = x1,
        y = y1,
   draw_pixel(img,x,y,color);
   bresenham_VA_dotted(img,color,y+1,y2,x,d,xincr,aincr,bincr,dl_test,draw,empty,1).
       
define One
   bresenham_VA_dotted
     (
       RGBAImage  img,
       RGBA       color,
       Int      x1,
       Int      y1,
       Int      x2,
       Int      y2,
       Int      pxd,
       Int      pxe
     ) = 
   with draw = draw(draw_test(pxd)),
   bresenham_VA_dotted(img,color,x1,y1,x2,y2,draw,draw,empty(empty_test(pxe))).
   
define One
   bresenham_HA_dotted
     (
       RGBAImage       img,
       RGBA            color,
       Int           x,
       Int           x2,
       Int           y,
       Int           d,
       Int           yincr,
       Int           aincr,
       Int           bincr,
       DottedLineTest  dl_test,
       DottedLineTest  draw,
       DottedLineTest  empty,
       Int           i
     ) =
   if x > x2 then unique else
   if d >= 0
     then with y_ = y+yincr,
          if dl_test is 
            {
              draw(test) then 
                if test(i) 
                  then draw_pixel(img,x,y_,color);
                       bresenham_HA_dotted(img,color,x+1,x2,y_,d+aincr,yincr,aincr,bincr,
                                           dl_test,draw,empty,i+1)
                  else bresenham_HA_dotted(img,color,x+1,x2,y_,d+aincr,yincr,aincr,bincr,
                                           empty,draw,empty,0),
              empty(test) then 
                if test(i)
                  then bresenham_HA_dotted(img,color,x+1,x2,y_,d+aincr,yincr,aincr,bincr,
                                           dl_test,draw,empty,i+1)
                  else bresenham_HA_dotted(img,color,x+1,x2,y_,d+aincr,yincr,aincr,bincr,
                                           draw,draw,empty,0)
            }
   
     else if dl_test is 
            {
              draw(test) then 
                if test(i) 
                  then draw_pixel(img,x,y,color);
                       bresenham_HA_dotted(img,color,x+1,x2,y,d+bincr,yincr,aincr,bincr,
                                           dl_test,draw,empty,i+1)
                  else bresenham_HA_dotted(img,color,x+1,x2,y,d+bincr,yincr,aincr,bincr,
                                           empty,draw,empty,0),
              empty(test) then 
                if test(i)
                  then bresenham_HA_dotted(img,color,x+1,x2,y,d+bincr,yincr,aincr,bincr,
                                           dl_test,draw,empty,i+1)
                  else bresenham_HA_dotted(img,color,x+1,x2,y,d+bincr,yincr,aincr,bincr,
                                           draw,draw,empty,0)
            }.

   
define One
   bresenham_HA_dotted
     (
       RGBAImage       img,
       RGBA            color,
       Int           x1,
       Int           y1,
       Int           x2,
       Int           y2,
       DottedLineTest  dl_test,
       DottedLineTest  draw,
       DottedLineTest  empty
     ) =
   with yincr = (Int)(if y2 > y1 then 1 else (0-1)),
        dx = x2 - x1,
        dy = abs(y2 - y1),
        d = 2 * dy - dx,
        aincr = 2 * (dy - dx),
        bincr = 2 * dy,
   draw_pixel(img,x1,y1,color);
   bresenham_HA_dotted(img,color,x1+1,x2,y1,d,yincr,aincr,bincr,dl_test,draw,empty,1).
   
define One
   bresenham_HA_dotted
     (
       RGBAImage  img,
       RGBA       color,
       Int      x1,
       Int      y1,
       Int      x2,
       Int      y2,
       Int      pxd,
       Int      pxe
     ) =
   with draw = draw(draw_test(pxd)),
   bresenham_HA_dotted(img,color,x1,y1,x2,y2,draw,draw,empty(empty_test(pxe))).
   

   
   
public define One
   draw_dotted_line
     (
       RGBAImage       img,
       RGBA            color,
       (Int,Int)   point1,
       (Int,Int)   point2,
       Int           pxd,
       Int           pxe
     ) = 
   if point1 is (x1,y1) then
   if point2 is (x2,y2) then
   if y1=y2 then
      (if x1<x2 then draw_H_dotted_line(img,color,x1,x2,y1,pxd,pxe)
                else draw_H_dotted_line(img,color,x2,x1,y1,pxd,pxe)) else
   if x1=x2 then
      (if y1<y2 then draw_H_dotted_line(img,color,y1,y2,x1,pxd,pxe)
                else draw_H_dotted_line(img,color,y2,y1,x1,pxd,pxe)) else
   
   if abs(x2-x1) < abs(y2-y1)
     then // vertical axis (VA)
          if y1 > y2
            then bresenham_VA_dotted(img,color,x2,y2,x1,y1,pxd,pxe)
            else bresenham_VA_dotted(img,color,x1,y1,x2,y2,pxd,pxe)
     else // horizontal axis (HA)
          if x1 > x2
            then bresenham_HA_dotted(img,color,x2,y2,x1,y1,pxd,pxe)
            else bresenham_HA_dotted(img,color,x1,y1,x2,y2,pxd,pxe).

   
public define One
   draw_line
     (
       RGBAImage       img,
       RGBA            color,
       (Int,Int)   point1,
       (Int,Int)   point2,
       LineLook        llook
     ) = 
   if llook is 
     {
       no_line         then 
         (if point1 is (x,y) then draw_pixel(img,x,y,color));
         (if point2 is (x,y) then draw_pixel(img,x,y,color)),
       filled          then draw_line(img,color,point1,point2),
       dotted(pxd,pxe) then draw_dotted_line(img,color,point1,point2,pxd,pxe)
     }.

   
public define One
   draw_line
     (
       RGBAImage       img,
       RGBA            color,     // line color
       (Int,Int)   point1,
       (Int,Int)   point2,
       (Int,Int)   origin,
       LineLook        llook
     ) = 
   if point1 is (x1,y1) then 
   if point2 is (x2,y2) then 
   if origin is (xo,yo) then 
   draw_line(img,color,(xo+x1,yo-y1),(xo+x2,yo-y2),llook).

   
   
   
   *** [2] Draw curve line

      *** [2.1] filled line without mark
   
define One 
   draw_bl_marks
     (
       RGBAImage             img,
       List((Int,Int))   points,
       (Int,Int) -> One  draw_mark
     ) =
   if points is 
     {
       []      then unique,
       [h . t] then 
         if h is (x,y) then draw_mark(x,y);
         draw_bl_marks(img,t,draw_mark)
     }.
   
   
public define One
   draw_curve_line
     (
       RGBAImage             img,
       RGBA                  color,
       (Int,Int)         p,
       List((Int,Int))   points,
     ) =
   if points is 
     {
       []      then unique,
       [h . t] then 
         draw_line(img,color,p,h);
         draw_line(img,color,h,p);
         draw_curve_line(img,color,h,t)
     }.
   
public define One
   draw_curve_line
     (
       RGBAImage            img,
       RGBA                 color,
       List((Int,Int))  points
     ) =
   if points is
     {
       []      then unique,
       [h . t] then 
         if t is []
          then (if h is (x,y) then draw_pixel(img,x,y,color))
          else draw_curve_line(img,color,h,t)
     }.

   
public define One
   draw_curve_line
     (
       RGBAImage             img,
       RGBA                  color,
       List((Int,Int))   points,
       (Int,Int) -> One  draw_mark
     ) =
   draw_curve_line(img,color,points);
   draw_bl_marks(img,points,draw_mark).


   
      *** [2.2] dotted line with marks

public define (Int,Int) -> One
   draw_curve_line_mark
     (
       RGBAImage        img,
       CurveLineMark    mark
     ) =
   if mark is 
     {
       none          then (Int x,Int y) |-> unique,
       circle(s,c)   then (Int x,Int y) |-> draw_circle(img,c,x,y,px_CMS(s)),
       disk(s,c)     then (Int x,Int y) |-> draw_disk(img,c,x,y,px_CMS(s)),
       square(s,c)   then 
         with px = px_CMS(s),
         (Int x,Int y) |-> draw_empty_rectangle(img,c,rect(x-px,y-px,x+px,y+px)),
       fsquare(s,c)  then 
         with px = px_CMS(s),
         (Int x,Int y) |-> draw_rectangle(img,rect(x-px,y-px,x+px,y+px),c),
       triangle(s,c) then 
         if s is 
           {
             small  then (Int x,Int y) |-> unique,
             medium then (Int x,Int y) |-> unique,
             big    then (Int x,Int y) |-> unique,
           },
     }.
   
   
   
define One
   draw_curve_dotted_line
     (
       RGBAImage            img,
       RGBA                 color,
       (Int,Int)        p,
       List((Int,Int))  points,
       Int                pxd,
       Int                pxe
     ) =
   if points is 
     {
       []      then unique,
       [h . t] then 
         draw_dotted_line(img,color,p,h,pxd,pxe);
         draw_dotted_line(img,color,h,p,pxd,pxe);
         draw_curve_dotted_line(img,color,h,t,pxd,pxe)
     }.
   
define One 
   draw_bl_marks
     (
       RGBAImage                           img,
       List((Int,Int,CurveLineMark))   points
     ) =
   if points is 
     {
       []      then unique,
       [h . t] then 
         if h is (x,y,mark) then draw_curve_line_mark(img,mark)(x,y);
         draw_bl_marks(img,t)
     }.
   
public define One
   draw_curve_line
     (
       RGBAImage            img,
       RGBA                 color,
       List((Int,Int))  points,
       LineLook             llook,
       CurveLineMark        mark
     ) =
   if points is
     {
       []      then unique,
       [h . t] then 
         if t is []
          then (if h is (x,y) then draw_pixel(img,x,y,color))
          else with draw_mark = draw_curve_line_mark(img,mark),
               if llook is 
                 {
                   no_line         then unique,
                   filled          then draw_curve_line(img,color,h,t),
                   dotted(pxd,pxe) then draw_curve_dotted_line(img,color,h,t,pxd,pxe)
                 };
               draw_bl_marks(img,points,draw_mark)
     }.
   
public define One
   draw_curve_line
     (
       RGBAImage                          img,
       RGBA                               color,
       List((Int,Int,CurveLineMark))  points,
       LineLook                           llook
     ) =
   if points is
     {
       []      then unique,
       [h . t] then 
         if h is (x,y,mark) then
         if t is []
          then draw_pixel(img,x,y,color)
          else if llook is 
                 {
                   no_line         then unique,
                   filled          then draw_curve_line(img,color,(x,y),
                                           map(((Int,Int,CurveLineMark) pts) |-> 
                                                         if pts is (xp,yp,_) then (xp,yp),t)),
                   dotted(pxd,pxe) then draw_curve_dotted_line(img,color,(x,y),
                                           map(((Int,Int,CurveLineMark) pts) |-> 
                                                         if pts is (xp,yp,_) then (xp,yp),t),
                                           pxd,pxe)
                 };
               draw_bl_marks(img,points)
     }.
   
   *** [3] Draw circle

   Reference : http://fr.wikipedia.org/wiki/Algorithme_de_trac%C3%A9_d'arc_de_cercle_de_Bresenham
   
   
   Notation des octants : 
   
      \      |      /
       \  3  |  2  /
        \    |    /
         \   |   /
          \  |  /
      4    \ | /    1
            \|/
   ----------------------
            /|\
      5    / | \    8
          /  |  \
         /   |   \
        / 6  |  7 \
       /     |     \
   
  

public define One
   draw_circle
     (
       RGBAImage   img,
       RGBA        color,
       Int       cx,
       Int       cy,
       Int       r,
       Int       m,
       Int       x,
       Int       y
     ) =
   if x > y then unique else
   draw_pixel(img,cx+y,cy-x,color);   // 1
   draw_pixel(img,cx+x,cy-y,color);   // 2
   draw_pixel(img,cx-x,cy-y,color);   // 3
   draw_pixel(img,cx-y,cy-x,color);   // 4
   draw_pixel(img,cx-y,cy+x,color);   // 5
   draw_pixel(img,cx-x,cy+y,color);   // 6
   draw_pixel(img,cx+x,cy+y,color);   // 7
   draw_pixel(img,cx+y,cy+x,color);   // 8
   if m > 0
     then draw_circle
            (img,color,cx,cy,r,m+8*x+4-8*y,x+1,y-1)
     else draw_circle
            (img,color,cx,cy,r,m+8*x+4,x+1,y).
      
   
public define One
   draw_circle
     (
       RGBAImage   img,
       RGBA        color,
       Int       cx,
       Int       cy,
       Int       r
     ) =
   draw_circle
     (img,color,cx,cy,r,
      5 - 4 * r,
      0,r).
   
   
   
   *** [4] Disk

   Pour dessiner un disque, il suffit  de tracer des segments de droites horizontales dont
   les 2 points sont données par le cercle délimitant ce disque.
   
public define One
   draw_disk
     (
       RGBAImage   img,
       RGBA        color,
       Int       cx,
       Int       cy,
       Int       r,
       Int       m,
       Int       x,
       Int       y
     ) =
   if x > y then unique else
     draw_H_line(img,color,cx-x,cx+x,cy-y);
     draw_H_line(img,color,cx-y,cx+y,cy-x);
     draw_H_line(img,color,cx-y,cx+y,cy+x);
     draw_H_line(img,color,cx-x,cx+x,cy+y);
   if m > 0
     then draw_disk
            (img,color,cx,cy,r,m+8*x+4-8*y,x+1,y-1)
     else draw_disk
            (img,color,cx,cy,r,m+8*x+4,x+1,y).

 
public define One
   draw_disk
     (
       RGBAImage   img,
       RGBA        color,
       Int       cx,
       Int       cy,
       Int       r
     ) =
   draw_disk
     (img,color,cx,cy,r,
      5 - 4 * r,
      0,r).
   
   
   
   
   *** [5] Ellipse
   
   Reference : A Fast Bresenham type Algorithm For Drawing Ellipses
               by John Kennedy
   
                http://homepage.smc.edu/kennedy_john/BELIPSE.PDF
   
   
define One
   ellipse_pixels
     (
       RGBAImage   img,
       RGBA        color,
       Int       cx,
       Int       cy,
       Int       x,
       Int       y
     ) =
   draw_pixel(img,cx+x,cy+y,color);   // quadran 1
   draw_pixel(img,cx-x,cy+y,color);   // quadran 2
   draw_pixel(img,cx-x,cy-y,color);   // quadran 3
   draw_pixel(img,cx+x,cy-y,color).   // quadran 4
       
   
   
define One
   draw_ellipse_1
     (
       Int                 _2asquare,
       Int                 _2bsquare,
       Int                 x,
       Int                 y,
       Int                 xchange,
       Int                 ychange,
       Int                 ee,         // ellipse error
       Int                 stopx,
       Int                 stopy,
       (Int,Int) -> One  plot_pixels
     ) =
   if stopx < stopy then unique else
     plot_pixels(x,y);
     if (2 * ee + xchange) > 0
       then draw_ellipse_1(_2asquare,_2bsquare,
                           x-1,y+1,
                           xchange+_2bsquare,ychange+_2asquare,
                           ee+ychange+xchange,
                           stopx-_2bsquare,stopy+_2asquare,
                           plot_pixels)
       else draw_ellipse_1(_2asquare,_2bsquare,
                           x,y+1,
                           xchange,ychange+_2asquare,
                           ee+ychange,
                           stopx,stopy+_2asquare,
                           plot_pixels).
   
   
   
define One
   draw_ellipse_2
     (
       Int                 _2asquare,
       Int                 _2bsquare,
       Int                 x,
       Int                 y,
       Int                 xchange,
       Int                 ychange,
       Int                 ee,         // ellipse error
       Int                 stopx,
       Int                 stopy,
       (Int,Int) -> One  plot_pixels
     ) =
   if stopx > stopy then unique else
     plot_pixels(x,y);
     if (2*ee + ychange) > 0
       then draw_ellipse_2
              (_2asquare,_2bsquare,
               x+1,y-1,
               xchange+_2bsquare,ychange+_2asquare,
               ee+xchange+ychange,
               stopx+_2bsquare,stopy-_2asquare,
               plot_pixels)
       else draw_ellipse_2
              (_2asquare,_2bsquare,
               x+1,y,
               xchange+_2bsquare,ychange,
               ee+xchange,
               stopx+_2bsquare,stopy,
               plot_pixels).
   
   
define One
   draw_ellipse
     (
       Int                 a,        // length of bigger radius
       Int                 b,         // length of smaller radius
       (Int,Int) -> One  plot_pixels
     ) =
   with _2asquare = 2*(a*a),
   with _2bsquare = 2*(b*b),
   draw_ellipse_1
     (_2asquare,_2bsquare,
      a,0,                     // x & y
      (b*b)*(1 - 2*a), a*a,    // xchange,ychange,
      0,_2bsquare*a,0,         // e,stopx,stopy
      plot_pixels);
   draw_ellipse_2
     (_2asquare,_2bsquare,
      0,b,                       // x & y
      (b*b), (a*a) * (1 - 2*b),  // xchange,ychange,
      0,0,_2asquare*b,           // e,stopx,stopy
      plot_pixels).
   
   
public define One
   draw_ellipse
     (
       RGBAImage   img,
       RGBA        color,
       Int       cx,
       Int       cy,
       Int       a,        // length of bigger radius
       Int       b         // length of smaller radius
     ) =
   draw_ellipse
     (a,b,
      (Int x,Int y) |-> ellipse_pixels(img,color,cx,cy,x,y)).

   

   *** [6] Filled ellipse
   
   
define One
   filled_ellipse_pixels
     (
       RGBAImage   img,
       RGBA        color,
       Int       cx,
       Int       cy,
       Int       x,
       Int       y
     ) =
   draw_H_line(img,color,cx-x,cx+x,cy+y);
   draw_H_line(img,color,cx-x,cx+x,cy-y).
       
   
   
   
public define One
   draw_filled_ellipse
     (
       RGBAImage   img,
       RGBA        color,
       Int       cx,
       Int       cy,
       Int       a,        // length of bigger radius
       Int       b         // length of smaller radius
     ) =
   draw_ellipse
     (a,b,
      (Int x,Int y) |-> filled_ellipse_pixels(img,color,cx,cy,x,y)).

   
   
   *** [7] Draw triangle
   
   
      *** [7.1] Empty triangle
   
public define One
   draw_triangle
     (
       RGBAImage      img,
       RGBA           color,
       (Int,Int)  summit1,
       (Int,Int)  summit2,
       (Int,Int)  summit3
     ) = 
   draw_curve_line(img,color,[summit1,summit2,summit3,summit1]).


      *** [7.2] Filled triangle

   

   *** [8] Draw empty rectangle 
   
public define One
   draw_empty_rectangle
     (
       RGBAImage   img,
       RGBA        color,
       Rectangle   rect
     )    =   
   if  rect is rect(x,y,u,v)  then
   draw_H_line(img,color,to_Int(x),to_Int(u),to_Int(y));
   draw_H_line(img,color,to_Int(x),to_Int(u),to_Int(v));
   draw_V_line(img,color,to_Int(y),to_Int(v),to_Int(x));
   draw_V_line(img,color,to_Int(y),to_Int(v),to_Int(u)).