anchor.diff:  
   (defmethod region-difference ((a standard-rectangle) (b standard-polygon))
     (polygon-op a b #'logandc2))
  +
  +;;; Lazy evaluation of a bounding rectangle.
  +(defmethod slot-unbound (class (self cached-bbox-mixin) (slot-name (eql 'bbox)))
  +  (setf (slot-value self 'bbox)
  +        (make-instance 'standard-bounding-rectangle
  +                       :x1 (reduce #'min (mapcar #'point-x (polygon-points self)))
  +                       :y1 (reduce #'min (mapcar #'point-y (polygon-points self)))
  +                       :x2 (reduce #'max (mapcar #'point-x (polygon-points self)))
  +                       :y2 (reduce #'max (mapcar #'point-y (polygon-points self))))))
  +
  +(defmethod bounding-rectangle* ((self cached-bbox-mixin))
  +  (with-standard-rectangle (x1 y1 x2 y2)
  +      (bounding-rectangle self)
  +    (values x1 y1 x2 y2)))
  +
  +(defmethod region-contains-position-p ((self standard-polygon) x y)
  +  (and (region-contains-position-p (bounding-rectangle self) x y)
  +       ;; The following algorithm is a Winding Number (wn) method implementation
  +       ;; based on a description by Dan Sunday "Inclusion of a Point in a
  +       ;; Polygon" (http://geomalgorithms.com/a03-_inclusion.html).
  +       (flet ((is-left (x0 y0 x1 y1 x2 y2)
  +                (- (* (- x1 x0) (- y2 y0))
  +                   (* (- x2 x0) (- y1 y0)))))
  +         (let ((x (coerce x 'coordinate))
  +               (y (coerce y 'coordinate))
  +               (wn 0))
  +           (map-over-polygon-segments
  +            (lambda (x1 y1 x2 y2)
  +              (if (<= y1 y)
  +                  (when (and (> y2 y)
  +                             (> (is-left x1 y1 x2 y2 x y) 0))
  +                    (incf wn))
  +                  (when (and (<= y2 y)
  +                             (< (is-left x1 y1 x2 y2 x y) 0))
  +                    (decf wn))))
  +            self)
  +           (not (zerop wn))))))
   
   (defun polygon-op (pg1 pg2 &optional logop)
     (let ((sps nil))
  
positive.code: 
  ;;; -- 2.5.3 Polygons and Polylines in CLIM ----------------------------------
  
  ;; Protocol:
  (defclass standard-polyline (polyline)
    ((points :initarg :points)
     (closed :initarg :closed)))
  
  (defclass standard-polygon (polygon)
    ((points :initarg :points)))
  
  ;;; -- 2.5.3.1 Constructors for CLIM Polygons and Polylines  -----------------
  
  (defun make-polyline (point-seq &key closed)
    (assert (every #'pointp point-seq))
    (setq point-seq (coerce point-seq 'list))
    (cond ((every (lambda (x) (region-equal x (car point-seq)))
                  (cdr point-seq))
           +nowhere+)
          (t
           (make-instance 'standard-polyline :points point-seq :closed closed))))
  
  (defun make-polyline* (coord-seq &key closed)
    (make-polyline (coord-seq->point-seq coord-seq) :closed closed))
  
  (defun make-polygon (point-seq)
    (assert (every #'pointp point-seq))
    (setq point-seq (coerce point-seq 'list))
    (cond ((every (lambda (x) (region-equal x (car point-seq)))
                  (cdr point-seq))
           +nowhere+)
          (t
           (make-instance 'standard-polygon :points point-seq))))
  
  (defun make-polygon* (coord-seq)
    (make-polygon (coord-seq->point-seq coord-seq)))
  
  (defmethod polygon-points ((self standard-polygon))
    (with-slots (points) self
      points))
  
  (defmethod map-over-polygon-coordinates (fun (self standard-polygon))
    (with-slots (points) self
  
negative.code:             ((null (cdr res)) (car res))
              (t (make-instance 'standard-region-union :regions res))))))
  
  (defmethod region-intersection ((a standard-line) (b standard-polygon))
    (multiple-value-bind (x1 y1) (line-start-point* a)
      (multiple-value-bind (x2 y2) (line-end-point* a)
  