PROGRAM NETZ (INPUT,OUTPUT,GRAPHIC);                        
(* DREIDIMENSIONALE NETZGRAFIK MIT EINFACHEM 'HIDDEN-LINE'*)
(* ALGORITHMUS.                                           *)
(* 29.9.1986 FLORIAN MATTHES                           *)   
                                                            
  CONST MAXN = 100; (* MAX. ANZAHL AN PUNKTEN IN X-       *)
                    (* RICHTUNG - 1                       *)
        ORGX = 0;   (* LAGE LINKE VORDERE ECKE AUF BILD   *)
        ORGY = 150; (* LAGE LINKE VORDERE ECKE AUF BILD   *)
        MAXX = 320; (* MAXIMALE BILDSCHIRMKOORDINATE IN X *)
        MAXY = 400; (* MAXIMALE BILDSCHIRMKOORDINATE IN Y *)
        YXSCALE = 0.5;(* LAENGE DER PROJEKTION EINER      *)
                      (* STRECKE DER LAENGE 1 AUF DER Y-  *)
                      (* ACHSE IN X-RICHTUNG              *)
        YYSCALE = 0.5;(* DSGL. IN Y-RICHTUNG              *)
        BACK    = #157 #157 #157; (* CURSOR 3 * <--       *)
                                                            
  TYPE  VISIBILITY = (ABOVE, HIDDEN, BELOW, BORDER);        
        LOCATION   =                                        
                  RECORD                                    
                    X,Y  : INTEGER;    (* BILDSCHIRMKOORD.*)
                    WHERE: VISIBILITY; (* SICHTBARKEIT    *)
                    YMAX : INTEGER;    (* BISHERIGE MAXIMA*)
                    YMIN : INTEGER;    (* UND MINIMA      *)
                  END;                                      
                                                            
  VAR   P: ARRAY[0..MAXN] OF      (* NUR EINE ZEILE! *)     
             LOCATION;                                      
        N: INTEGER;  (* ANZAHL DER PUNKTE IN X/Y RICHTUNG *)
                                                            
        XU,XO,YU,ZM: REAL;     (* DARZUSTELLENDER BEREICH *)
        ROW, POINT  : INTEGER; (* LFD. POSITION IM NETZ   *)
        ISFIRST     : BOOLEAN; (* IN DER ERSTEN REIHE TRUE*)
        NEW         : LOCATION;             (* LFD. PUNKT *)
        D           : REAL;    (* SCHRITTWEITE            *)
        YAKT,XAKT   : REAL;    (* LFD. FUNKTIONSWERTE     *)
        SIZE        : REAL;    (* PIXEL-ABSTAND IN X      *)
        XADD, YADD  : INTEGER; (* OFFSET IN PIXELN FUER   *)
                               (* DIE LFD. ZEILE          *)
                                                            
  FUNCTION F(X,Y:REAL): REAL;                               
  (* DARZUSTELLENDE FUNKTION. ABBILDUNG R * R --> R *)      
    CONST EPS = 1.0E-5;                                     
    VAR   D : REAL;                                         
  BEGIN                                                     
    D:= SQRT(X*X+Y*Y);                                      
    IF D<=EPS THEN F:=1.0                                   
              ELSE F:= SIN(D) / D;                          
  END; (* F *)                                              
                                                            
  PROCEDURE DRAWLINE(VAR P,Q: LOCATION);                    
  (* VERBINDE P MIT Q, FALLS LINIE SICHTBAR IST           *)
  BEGIN                                                     
    CASE P.WHERE OF                                         
      ABOVE : IF Q.WHERE=ABOVE THEN                         
                DRAW(1,P.X,P.Y,Q.X,Q.Y)                     
              ELSE                                          
                DRAW(1,P.X,P.Y,Q.X,Q.YMAX);                 
      HIDDEN: CASE Q.WHERE OF                               
                BORDER,                                     
                ABOVE : DRAW(1,P.X,P.YMAX,Q.X,Q.Y);         
                HIDDEN:;(* NICHTS *)                        
                BELOW : DRAW(1,P.X,P.YMIN,Q.X,Q.Y);         
              END;                                          
      BELOW : IF Q.WHERE=BELOW THEN                         
                DRAW(1,P.X,P.Y,Q.X,Q.Y)                     
              ELSE                                          
                DRAW(1,P.X,P.Y,Q.X,Q.YMIN);                 
      BORDER: DRAW(1,P.X,P.Y,Q.X,Q.Y);                      
    END; (* CASE *)                                         
  END; (* DRAWLINE *)                                       
                                                            
BEGIN                                                       
  SCNCLR;                                                   
  WRITELN('ANZAHL DER STUETZSTELLEN IN');                   
  WRITE('X- UND Y-RICHTUNG:  30',BACK); READLN(N);          
  WRITELN; N:= N-1;                                         
  WRITE('X VON   : -10',BACK); READLN(XU);                  
  WRITE('X BIS   :   0',BACK); READLN(XO);                  
  WRITE('Y VON   : -10',BACK); READLN(YU);                  
  WRITE('Z FAKTOR: 150',BACK); READLN(ZM);                  
                                                            
  GRAPHIC(1,1);                                             
                                                            
  D:= (XO-XU)/N; (* SCHRITTWEITE *)                         
  SIZE:= (MAXX-ORGX) / ((1.0 + YXSCALE)*N);                 
                                                            
  ISFIRST:= TRUE; YAKT:= YU;                                
  (* ZEILENWEISE Y VON VORNE NACH HINTEN ERHOEHEN:        *)
  FOR ROW:= 0 TO N DO                                       
    BEGIN                                                   
      (* BERECHNE KONSTANTEN FUER DIESE REIHE:            *)
      XADD:= ORGX + INT(ROW*SIZE*YXSCALE);                  
      YADD:= ORGY - INT(ROW*SIZE*YYSCALE);                  
      (* = OFFSET NACH RECHTS UND UNTEN *)                  
                                                            
      XAKT:=XU;                                             
      FOR POINT:= 0 TO N DO                                 
       WITH NEW DO                                          
          BEGIN                                             
            (* BERECHNE PUNKT IN BILDSCHIRMKOORDINATEN    *)
            X:= INT(POINT * SIZE) + XADD;                   
            Y:= YADD - INT( F(XAKT,YAKT) * ZM);             
                                                            
            IF (POINT=N) OR ISFIRST THEN                    
              BEGIN                                         
                YMAX:= Y; YMIN:= Y; WHERE:= BORDER          
              END                                           
            ELSE                                            
              BEGIN                                         
              (* BESTIMME EXTREMWERTE AUS DEN ALTEN EX-   *)
              (* TREMWERTEN UND DER AKTUELLEN Y-KOORDINATE*)
              (* DARAUS FOLGT AUCH DIE SICHTBARKEIT       *)
              YMAX:= (P[POINT].YMAX+P[POINT+1].YMAX) DIV 2; 
              YMIN:= (P[POINT].YMIN+P[POINT+1].YMIN) DIV 2; 
              IF Y>YMAX THEN                                
                BEGIN                                       
                  YMAX:= Y; WHERE:=ABOVE;                   
                END                                         
              ELSE                                          
                IF Y<YMIN THEN                              
                  BEGIN                                     
                    YMIN:= Y; WHERE:=BELOW;                 
                  END                                       
                ELSE                                        
                  WHERE:= HIDDEN;                           
              END; (* WITH *)                               
                                                            
            (* VERBINDE PUNKT MIT NACHBARN, SOWEIT VOR- *)  
            (* HANDEN UND SICHTBAR                      *)  
            IF NOT ISFIRST THEN         (* NACH 'VORNE' *)  
              DRAWLINE(P[POINT],NEW);                       
            IF POINT<>0 THEN            (* NACH 'LINKS' *)  
              DRAWLINE(P[POINT-1],NEW);                     
            P[POINT]:= NEW;                                 
          XAKT:= XAKT + D;             (* NAECHSTER PUNKT *)
        END; (* FOR POINT *)                                
    YAKT:= YAKT+D;                     (* NAECHSTE REIHE  *)
    ISFIRST:= FALSE;                                        
  END; (* FOR ROW *)                                        
                                                            
  REPEAT UNTIL KEYPRESSED;                                  
  GRAPHIC(0);                                               
END.