FUNCIÓN LINEA

Las dos funciones más importantes gráficas son: el circulo y la recta. A partir  de ellas podremos generar el resto de funciones.

   En las entradas anteriores he colocado la función básica de putpixel, para dibujar un punto, con la cual se podrán generar el resto de las funciones. En este caso he usado, por comodidad la Int 10h de la Bios., pero si alguien quiere puede hacer un putpixel directamente sobre memoria de pantalla. Esta modificación no influirá en el resto de las funciones ya que si se hace el putpixel de forma equivalente, el resto de las funciones seguirán siendo válidas.

    La recta es una función en principio compleja si la queremos hacer sin usar operaciones matemáticas complejas.

     Actualmente, debido a que los ordenadores son potentes, y se trabaja en alto nivel, a cualquiera que se le proponga hacer una recta mediante pixel, utilizará la ecuación de la recta y a correr. Pero si trabajamos en ensamblador, bien sea el que estamos usando, o sea un microcontrolador, de manera que deseemos trazar una línea en un papel mediante motores paso a paso, resulta problemático usar coma flotante.

     En 1965 Bresenham creó unos algoritmos de aproximación para la recta y los círculos, los cuales son capaces de trazar una recta usando solo operaciones incrementales y  operaciones básicas de  ensamblador como multiplica por 2 y sumar.

     Este es el algoritmo que he utilizado en esta función. Este algoritmo es válido solo si la pendiente es mayor de cero y menor de infinito. Es decir no sirve para rectas horizontales y verticales.

   Por lo tanto estos dos casos son tratados de forma independiente.

   Además hay que tratar el caso de trazar la recta en los dos sentidos, para lo cual lo que realizamos es una comprobación del sentido para poner los incrementos (pasox y pasoy) en +1 o -1 según convenga.

   Además el algoritmo solo sirve para un cuadrante, es decir no es lo mismo si la recta aumenta más deprisa en x que en y que si la recta aumenta más deprisa en y que en x. Por ello hay que verificar si Δx> Δy y tomar un algoritmo diferente.

   Como el algoritmo lo podréis encontrar en internet, pero nunca en ensamblador, he decidido hacer un ejercicio de interpretación muy elegante.

    Os he colocado como comentario a la derecha el código equivalente en “C”. Es decir he puesto el código en ensamblador, traduciéndolo a “C”. Esto servirá a muchos para entender el algoritmo, pero a muchos más, para saber cómo codificar en ensamblador  cada directiva de “C”.

    Esto que he hecho, para mi es super sencillo, porque yo comencé con desensamblar y luego pase a “C”, pero me imagino que para los programadores actuales, acostumbrados a lenguajes de alto nivel, es muy difícil hacerse una idea de cómo traducir el “C” a ensamblador.

    En este caso, yo he tomado el algoritmo en “C” y lo he traducido a ensamblador. Esto se puede hacer con cualquier pseudocódigo, por lo que esta entrada es una forma de enseñar este proceso.

   El conjunto de la librería estará formado por una macro, que deberá ser añadida a las cabeceras GRAPHICS.MAC,  que puse antes, y una función, que deberá ser compilada y añadida a la librería mediante TLIB. Así tendremos lista esta función para el futuro. Será usada como una instrucción más, y no tendremos que volver a compilarla, ni a preocuparnos de ella.

   Si se introduce, como yo hago, dentro de una librería, y siempre usamos esa librería, la función será transparente en  nuestras aplicaciones. Podéis ver cómo hacerlo en la pestaña COMPILAR del blog.

    Con esta función podremos realizar el rectangle y el fillrectangle, que pondré en la siguiente entrada.

    Más infornmación sobre el algoritmo  Aquí



GRAPHICS.MAC
;Dibuja una línea
line macro x0,y0,x1,y1,color
ifndef _line
        extrn _line:near
endif
        mov ax,x0
        push ax
        mov ax,y0
        push ax
        mov ax,x1
        push ax
        mov ax,y1
        push ax
        mov ax,color
        push ax
        call _line
       
 endm  




LINEA.ASM

; Copyright (C) 2013  José Ángel Moneo Fernández

;    This program is free software: you can redistribute it and/or modify
;    it under the terms of the GNU General Public License as published by
;    the Free Software Foundation, either version 3 of the License, or
;   (at your option) any later version.

;    This program is distributed in the hope that it will be useful,
;    but WITHOUT ANY WARRANTY; without even the implied warranty of
;    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
;    GNU General Public License for more details.

;    You should have received a copy of the GNU General Public License
;    along with this program.  If not, see <http://www.gnu.org/licenses/>.

include graphics.mac


.model compact,pascal

        public _line
.data


incE   dw 0
incNE dw 0


deltax dw 0    ;
deltay dw 0

pasox dw 0     ;paso en x
pasoy dw 0     ; paso en y

p dw 0     ;variable p procedimiento breshenham

x0 dw 0    ;parametros pasdados a linea
y0 dw 0    ;usado por todas las rutinas
x1 dw 0
y1 dw 0
color dw 0
.code
       ;algoritmo Bresenham
_line proc uses ax,px0,py0,px1,py1,pcolor
        ;paso de las variables de función a varialbes globales
        ;para uso en todas las rutinas
        mov ax,px0
        mov x0,ax
        mov ax,py0
        mov y0,ax
        mov ax,px1
        mov x1,ax
        mov ax,py1
        mov y1,ax
        mov ax,pcolor
        mov color,ax
       
       ;deltay=abs(yfinal-yinicial)
        mov ax,y1
        sub ax,y0               ; deltay=(y1-y0)
        jns  else_positivo1      ;if (deltay<0)
        neg ax                        ;{abx(deltay)
        mov pasoy,-1                  ;pasoy=-1
        jmp end_positivo1             ;}
else_positivo1:                  ;else
        mov pasoy,1                    ;pasoy=1
end_positivo1:
        mov deltay,ax           ; deltay=abs(y1-y0)
       
        ;deltax=abs(xfinal-xinicial)
        mov ax,x1
        sub ax,x0                ; deltax=(x1-x0)
        jns  elsepositivo2       ;if (deltax>0)
        neg ax                       ;{abx(deltax)
        mov pasox,-1                 ;pasox=-1
        jmp end_positivo2            ;}
elsepositivo2:                    ;else
        mov pasox,1                   ;pasox=1
end_positivo2:

        mov deltax,ax             ; deltax=abs(x1-x0)
        cmp ax,0                  ;if(deltax==0)
        jne no_vertical                  ;{
        call _linea_vertical      ;linea_vertical
        jmp fin_linea                        ;}
no_vertical:

        mov ax,deltay
        cmp ax,0                        ;if(deltay==0)
        jne no_horizontal                   ;{
        call _linea_Horizontal      ;linea_horizontal
        jmp fin_linea                      ;}
no_horizontal:
        
  ;resto de lineas mediante algoritmo Bresenham
        mov ax,deltax
        cmp ax,deltay                    ;if(deltax>deltay)
        jna alg2
        call _algoritmo1    ; algoritmo1
        jmp fin_linea
alg2:                                   ;else
        call _algoritmo2     ;algoritmo2
fin_linea:
        ret
_line endp

_linea_vertical proc uses ax bx cx dx
        mov bx,x0         ; x=x0
        mov dx,y0         ; y=y0
        mov cx,y1         ; yend=y1

while_vert:     
        cmp dx,cx               ;while (y!=yend)
        je fin_vert                  ;{
        putpixel bx,dx,color   ;pixel x,y
        add dx,pasoy                 ;y+=pasoy
        jmp while_vert
       
fin_vert:
        ret
_linea_vertical endp

_linea_horizontal proc uses ax bx cx dx
        mov bx,x0         ; x=x0
        mov dx,y0         ; y=y0
        mov cx,x1         ; xend=x1
      
while_hor:     
        cmp bx,cx               ;while (x!=xend)
        je fin_hor                  ;{
        putpixel bx,dx,color   ;pixel x,y
        add bx,pasox                 ;x+=pasox
        jmp while_hor
       
fin_hor:
        ret
_linea_horizontal endp


 ;si deltax>deltay
_algoritmo1 proc uses ax bx cx dx
        ;p=2*deltay-deltax
        mov ax,deltay         
        shl ax,1     
        mov incE,ax                 ;incE=2*deltay        
        sub ax,deltax          
        mov p,ax                    ;p=2*deltay-deltax 
         
        ;incNE=2*(deltay-deltax)
        mov ax, deltay
        sub ax,deltax
        shl ax,1
        mov incNE,ax                 ;incNE=2*(deltay-deltax)
         

        mov bx,x0         ; x=x0
        mov dx,y0         ; y=y0
        mov cx,x1         ; xend=x1

while1:     
        cmp bx,cx               ;while (x!=xend)
        je fin1                  ;{
        putpixel bx,dx,color   ;pixel x,y
        add bx,pasox                 ;x+=pasox
       
        mov ax,p
        cmp ax,0              ; if(p<0)
        jns else_if1
        add ax,incE
        mov p,ax              ;p+=incE
        jmp short end_if1
else_if1:                     ;else
        add ax,incNE
        mov p,ax             ;p+=incNE
        add dx,pasoy                ;y+=pasoy
end_if1:        
        jmp while1            ;}        
fin1:       
        ret
_algoritmo1 endp

;si deltay>deltax
 _algoritmo2 proc uses ax bx cx dx
        ;p=2*deltax-deltay
        mov ax,deltax         
        shl ax,1   
        mov incE,ax                 ;incE=2*deltay           
        sub ax,deltay          
        mov p,ax                    ;p=2*deltax-deltay 
        
        ;incNE=2*(deltax-deltay)
        mov ax, deltax
        sub ax,deltay
        shl ax,1
        mov incNE,ax                 ;incNE=2*(deltax-deltay)
         

        mov bx,x0         ; x=x0
        mov dx,y0         ; y=y0
        mov cx,y1         ; yend=y1
while2:         
        cmp dx,cx               ;while (y!=yend)
        je fin2                  ;{
        putpixel bx,dx,color   ;pixel x,y
        add dx,pasoy                ;y+=pasoy
       
        mov ax,p
        cmp ax,0              ; if(p<0)
        jns else_if2
        add ax,incE
        mov p,ax              ;p+=incE
        jmp short end_if2
else_if2:                     ;else
        add ax,incNE
        mov p,ax             ;p+=incNE
        add bx,pasox              ;x+=pasox 
end_if2:        
        jmp while2            ;}        
fin2:       
        ret
_algoritmo2 endp
end