;Autor: Bernd10 ?? (siehe www.cad.de)
;Verändert von Stephan Bartl (am 19.02.2009)

;-------------------------------------------------------------------------------------------------------------------------------------
;
; Schnittstelle zu anderen Modulen:
;
; INPUT 
; =====
;
; Parameter    :
;
; Typ    Variablename      Variablebeschreibung [Wertebereich]
; list   lboxref           Referenzbox
; list   lboxvgl           Vergleichsbox
; real   fuzz		   Toleranz für Gleichheitsprüfung (siehe equal) - darf auch nil (oder irgent etwas anderes) sein (default ist dann 0.0) <- *Änderung (auch im Code) von Stephan Bartl*
;
; OUTPUT
; ======
;
; Parameter    :
;
; Berührung wird als schneiden interprediert  <- *Änderung (auch im Code) von Stephan Bartl*
; Typ    Variablenname     Variablenbeschreibung  [Wertebereich]  
; int    ilage             Code für Lagemöglichkeiten der beiden Flächen
;			   00 -> Flächen liegen genau übereinander <- *Änderung (auch im Code) von Stephan Bartl*
;                          10 -> Vergleichsfläche links von der Referenzfläche
;                          20 -> Vergleichsfläche über der Referenzfläche
;                          30 -> Vergleichsfläche rechts von der Referenzfläche
;                          40 -> Vergleichsfläche unter der Referenzfläche
;                          50 -> Vergleichsfläche liegt vollständig in der Referenzfläche
;                          60 -> Vergleichsfläche überdeckt vollständig die Referenzfläche
;                          70 -> Vergleichsfläche schneidet Referenzfläche
;                          evtl. ermittelte 2. Stelle:
;                           1 -> vollständig links von der Referenzfläche
;                           2 -> vollständig über der Referenzfläche
;                           3 -> vollständig rechts von der Referenzfläche
;                           4 -> vollständig unter der Referenzfläche
;  
;-------------------------------------------------------------------------------------------------------------------------------------
;  
( defun lage_vergleichen_fuzz ( lboxref lboxvgl fuzz
                           / 
                           ilage 
                           lpktluref lpktluvgl lpktroref lpktrovgl 
                           rxluref rxluvgl rxroref rxrovgl ryluref ryluvgl ryroref ryrovgl )

; Die Werte für die Referenzbox ermitteln
  (setq lpktluref (nth 0 lboxref))
  (setq rxluref (nth 0 lpktluref))
  (setq ryluref (nth 1 lpktluref))
  (setq lpktroref (nth 1 lboxref))
  (setq rxroref (nth 0 lpktroref))
  (setq ryroref (nth 1 lpktroref))
  
; Die Werte für die Vergleichsbox ermitteln
  (setq lpktluvgl (nth 0 lboxvgl))
  (setq rxluvgl (nth 0 lpktluvgl)) 
  (setq ryluvgl (nth 1 lpktluvgl)) 
  (setq lpktrovgl (nth 1 lboxvgl))
  (setq rxrovgl (nth 0 lpktrovgl)) 
  (setq ryrovgl (nth 1 lpktrovgl)) 
  
; Den Code der Lage ermitteln
  (setq ilage 0)
  (if(and(/=(type fuzz)'REAL) (/=(type fuzz)'INT))
    (setq fuzz 0.0)
  )
  
  (cond

  ; VGL und REF sind ident
    ((and (equal rxluvgl rxluref fuzz) (equal ryluvgl ryluref fuzz) (equal rxrovgl rxroref fuzz) (equal ryrovgl ryroref fuzz))
      (setq ilage 00)
    )

  ; VGL liegt innerhalb von REF  (REF überdeckt VGL) 
    ((and (or(> rxluvgl rxluref) (equal rxluvgl rxluref fuzz)) (or(> ryluvgl ryluref) (equal ryluvgl ryluref fuzz))
          (or(< rxrovgl rxroref) (equal rxrovgl rxroref fuzz)) (or(< ryrovgl ryroref) (equal ryrovgl ryroref fuzz))
     )
      (setq ilage 50)
    )

  ; VGL umschliesst REF (VGL überdeckt REF)
    ((and (or(< rxluvgl rxluref) (equal rxluvgl rxluref fuzz)) (or(< ryluvgl ryluref) (equal ryluvgl ryluref fuzz))
          (or(> rxrovgl rxroref) (equal rxrovgl rxroref fuzz)) (or(> ryrovgl ryroref) (equal ryrovgl ryroref fuzz))
     )
      (setq ilage 60)
    )

  ; VGL liegt links von REF 
    ((and (< rxrovgl rxluref) (not(equal rxrovgl rxluref fuzz)))
      (setq ilage 10)  ; innerhalb der Y-Ausdehnung von REF
      (if (and (< ryrovgl ryluref) (not(equal ryrovgl ryluref fuzz)))
        (setq ilage 14)   ; unterhalb von REF
      ) ; if
      (if (and (> ryluvgl ryroref) (not(equal ryluvgl ryroref fuzz)))
        (setq ilage 12)   ; über REF
      ) ; if
    )

  ; VGL liegt rechts von REF
    ((and (> rxluvgl rxroref) (not(equal rxluvgl rxroref fuzz)))
      (setq ilage 30)  ; innerhalb der Y-Ausdehnung von REF
      (if (and (< ryrovgl ryluref) (not(equal ryrovgl ryluref fuzz)))
        (setq ilage 34)   ; unterhalb von REF
      ) ; if
      (if (and (> ryluvgl ryroref) (not(equal ryluvgl ryroref fuzz)))
        (setq ilage 32)   ; über REF
      ) ; if
    )

  ; VGL über REF
    ((and (> ryluvgl ryroref) (not(equal ryluvgl ryroref fuzz)))
      (setq ilage 20)  ; innerhalb der X-Ausdehnung von REF
      (if (and (< rxrovgl rxluref) (not(equal rxrovgl rxluref fuzz)))
        (setq ilage 23)   ; links von REF
      ) ; if
      (if (and (> rxluvgl rxroref) (not(equal rxluvgl rxroref fuzz)))
        (setq ilage 21)   ; rechts von REF
      ) ; if
    )

  ; VGL unterhalb von REF
    ((and (< ryrovgl ryluref) (not(equal ryrovgl ryluref fuzz)))
      (setq ilage 40)  ; innerhalb der X-Ausdehnung von REF
      (if (and (< rxrovgl rxluref) (not(equal rxrovgl rxluref fuzz)))
        (setq ilage 43)   ; links von REF
      ) ; if
      (if (and (> rxluvgl rxroref) (not(equal rxluvgl rxroref fuzz)))
        (setq ilage 41)   ; rechts von REF
      ) ; if
    )

  ; VGL schneidet REF
    (t   ; else
      (setq ilage 70)
    )
  ) ; cond

; Rückgabewert
  ilage

) ; Modulende