#
# Copyright (c) 2003, 2004, 2006 Art Haas
#
# This file is part of PythonCAD.
#
# PythonCAD 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 2 of the License, or
# (at your option) any later version.
#
# PythonCAD 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 PythonCAD; if not, write to the Free Software
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
#
#
# functions for splitting entities in a drawing

import math

from PythonCAD.Generic.layer import Layer
from PythonCAD.Generic.point import Point
from PythonCAD.Generic.segment import Segment
from PythonCAD.Generic.circle import Circle
from PythonCAD.Generic.arc import Arc
from PythonCAD.Generic.polyline import Polyline
from PythonCAD.Generic import util
from PythonCAD.Generic import intersections

_rtd = (180.0/math.pi)

def _most_used(plist):
    _pmax = plist.pop()
    _max = _pmax.countUsers()
    for _pt in plist:
        _count = _pt.countUsers()
        if _count > _max:
            _max = _count
            _pmax = _pt
    return _pmax

def _get_point(l, x, y):
    _pts = l.find('point', x, y)
    if len(_pts) == 0:
        _lp = Point(x, y)
        l.setAutosplit(False)
        l.addObject(_lp)
    else:
        _lp = _most_used(_pts)
    return _lp
    
def split_segment_at(seg, x, y):
    if not isinstance(seg, Segment):
        raise TypeError, "Invalid Segment: " + `type(seg)`
    _x = util.get_float(x)
    _y = util.get_float(y)
    _layer = seg.getParent()
    if _layer is None:
        return None
    _p = seg.getProjection(_x, _y)
    if _p is None:
        return None
    _px, _py = _p
    if abs(_px - _x) > 1e-10 or abs(_py - _y) > 1e-10:
        return None
    _lp = _get_point(_layer, _px, _py)
    _p1, _p2 = seg.getEndpoints()
    if _lp == _p1 or _lp == _p2:
        return None
    _s = seg.getStyle()
    _s1 = Segment(_p1, _lp, _s)
    _s2 = Segment(_lp, _p2, _s)
    _c = seg.getColor()
    if _s1.getColor() != _c:
        _s1.setColor(_c)
    if _s2.getColor() != _c:
        _s2.setColor(_c)
    _l = seg.getLinetype()
    if _s1.getLinetype() != _l:
        _s1.setLinetype(_l)
    if _s2.getLinetype() != _l:
        _s2.setLinetype(_l)
    _t = seg.getThickness()
    if abs(_s1.getThickness() - _t) > 1e-10:
        _s1.setThickness(_t)
    if abs(_s2.getThickness() - _t) > 1e-10:
        _s2.setThickness(_t)
    _layer.addObject(_s1)
    _layer.addObject(_s2)
    return _s1, _s2

def split_circle_at(circ, x, y):
    if not isinstance(circ, Circle):
        raise TypeError, "Invalid Circle: " + `type(circ)`
    _x = util.get_float(x)
    _y = util.get_float(y)
    _layer = circ.getParent()
    if _layer is None:
        return None
    _p = circ.mapCoords(_x, _y)
    if _p is None:
        return None
    _px, _py = _p
    if abs(_px - _x) > 1e-10 or abs(_py - _y) > 1e-10:
        return None
    _lp = _get_point(_layer, _px, _py)
    _s = circ.getStyle()
    _cp = circ.getCenter()
    _angle = _rtd * math.atan2((_py - _cp.y),(_px - _cp.x))
    _arc = Arc(_cp, circ.getRadius(), _angle, _angle, _s)
    _c = circ.getColor()
    if _arc.getColor() != _c:
        _arc.setColor(_c)
    _l = circ.getLinetype()
    if _arc.getLinetype() != _l:
        _arc.setLinetype(_l)
    _t = circ.getThickness()
    if abs(_arc.getThickness() - _t) > 1e-10:
        _arc.setThickness(_t)
    _layer.addObject(_arc)
    return _arc

def split_arc_at(arc, x, y):
    if not isinstance(arc, Arc):
        raise TypeError, "Invalid Arc: " + `type(arc)`
    _x = util.get_float(x)
    _y = util.get_float(y)
    _layer = arc.getParent()
    if _layer is None:
        return None
    _p = arc.mapCoords(_x, _y)
    if _p is None:
        return None
    _px, _py = _p
    if abs(_px - _x) > 1e-10 or abs(_py - _y) > 1e-10:
        return None
    _lp = _get_point(_layer, _px, _py)
    _s = arc.getStyle()
    _cp = arc.getCenter()
    _r = arc.getRadius()
    _sa = arc.getStartAngle()
    _ea = arc.getEndAngle()
    _angle = _rtd * math.atan2((_py - _cp.y),(_px - _cp.x))
    _a1 = Arc(_cp, _r, _sa, _angle, _s)
    _a2 = Arc(_cp, _r, _angle, _ea, _s)
    _c = arc.getColor()
    if _a1.getColor() != _c:
        _a1.setColor(_c)
    if _a2.getColor() != _c:
        _a2.setColor(_c)
    _l = arc.getLinetype()
    if _a1.getLinetype() != _l:
        _a1.setLinetype(_l)
    if _a2.getLinetype() != _l:
        _a2.setLinetype(_l)
    _t = arc.getThickness()
    if abs(_a1.getThickness() - _t) > 1e-10:
        _a1.setThickness(_t)
    if abs(_a2.getThickness() - _t) > 1e-10:
        _a2.setThickness(_t)
    _layer.addObject(_a1)
    _layer.addObject(_a2)
    return _a1, _a2

def split_polyline_at(pl, x, y):
    if not isinstance(pl, Polyline):
        raise TypeError, "Invalid Polyline: " + `type(pl)`
    _x = util.get_float(x)
    _y = util.get_float(y)
    _layer = pl.getParent()
    if _layer is None:
        return False
    _pts = pl.getPoints()
    for _i in range(len(_pts) - 1):
        _p1x, _p1y = _pts[_i].getCoords()
        _p2x, _p2y = _pts[_i + 1].getCoords()
        _p = util.map_coords(_x, _y, _p1x, _p1y, _p2x, _p2y)
        if _p is None:
            continue
        _px, _py = _p
        if ((abs(_px - _p1x) < 1e-10 and abs(_py - _p1y) < 1e-10) or
            (abs(_px - _p2x) < 1e-10 and abs(_py - _p2y) < 1e-10)):
            continue
        _lp = _get_point(_layer, _px, _py)
        pl.addPoint((_i + 1), _lp)
        return True
    return False

def split_segment(seg, pt):
    """Split a segment into two segments at a point.

split_segment(seg, pt)

seg: The segment to split
pt: The point used to split the segment.

There is presently no check to test that the point lies
on the segment.
    """
    if not isinstance(seg, Segment):
        raise TypeError, "Invalid Segment: " + `type(seg)`
    if not isinstance(pt, Point):
        raise TypeError, "Invalid Point: " + `type(pt)`
    _sp = seg.getParent()
    _pp = pt.getParent()
    if _sp is not None and _pp is not None and _sp is not _pp:
        raise RuntimeError, "Invalid Point for Segment splitting."
    _p1, _p2 = seg.getEndpoints()
    _s = seg.getStyle()
    _l = seg.getLinetype()
    _c = seg.getColor()
    _t = seg.getThickness()
    _s1 = Segment(_p1, pt, _s, _l, _c, _t)
    _s2 = Segment(pt, _p2, _s, _l, _c, _t)
    return _s1, _s2

def split_circle(circle, pt):
    """Split a circle into a single arc.

split_circle(circle, pt)

circle: The circle to split
pt: The point used to determine the start/end angles of the arc.
    """
    if not isinstance(circle, Circle):
        raise TypeError, "Invalid Circle: " + `type(circle)`
    if not isinstance(pt, Point):
        raise TypeError, "Invalid Point: " + `type(pt)`
    _cp = circle.getParent()
    _pp = pt.getParent()
    if _cp is not None and _pp is not None and _cp is not _pp:
        raise RuntimeError, "Invalid Point for Circle splitting."
    _cp = circle.getCenter()
    _rad = circle.getRadius()
    _cx, _cy = _cp.getCoords()
    _px, _py = pt.getCoords()
    _angle = _rtd * math.atan2((_py - _cy), (_px - _cx))
    if _angle < 0.0:
        _angle = _angle + 360.0
    return Arc(_cp, _rad, _angle, _angle,
                           circle.getStyle(), circle.getLinetype(),
                           circle.getColor(), circle.getThickness())

def split_arc(arc, pt):
    """Split an arc into two connected arcs.

split_arc(arc, pt)

arc: The arc to split.
pt: The point used to determine the angle at which to split the arc.
    """
    if not isinstance(arc, Arc):
        raise TypeError, "Invalid Arc: " + `type(arc)`
    if not isinstance(pt, Point):
        raise TypeError, "Invalid Point: " + `type(pt)`
    _ap = arc.getParent()
    _pp = pt.getParent()
    if _ap is not None and _pp is not None and _ap is not _pp:
        raise RuntimeError, "Invalid Point for Arc splitting."
    _cp = arc.getCenter()
    _cx, _cy = _cp.getCoords()
    _px, _py = pt.getCoords()
    _angle = _rtd * math.atan2((_py - _cy), (_px - _cx))
    if _angle < 0.0:
        _angle = _angle + 360.0
    if not arc.throughAngle(_angle):
        raise ValueError, "Arc does not exist at angle %g" % _angle
    _rad = arc.getRadius()
    _sa = arc.getStartAngle()
    _ea = arc.getEndAngle()
    _style = arc.getStyle()
    _linetype = arc.getLinetype()
    _color = arc.getColor()
    _thickness = arc.getThickness()
    _arc1 = Arc(_cp, _rad, _sa, _angle,
                            _style, _linetype, _color, _thickness)
    _arc2 = Arc(_cp, _rad, _angle, _ea,
                            _style, _linetype, _color, _thickness)
    return _arc1, _arc2

def split_polyline(polyline, pt):
    if not isinstance(polyline, Polyline):
        raise TypeError, "Invalid Polyline: " + `type(polyline)`
    if not isinstance(pt, Point):
        raise TypeError, "Invalid Point: " + `type(pt)`
    _plp = polyline.getParent()
    _pp = pt.getParent()
    if _plp is not None and _pp is not None and _plp is not _pp:
        raise RuntimeError, "Invalid Point for Polyline splitting."
    _px, _py = pt.getCoords()
    _count = len(polyline)
    for _i in range(_count - 1):
        _hit = False
        _p1x, _p1y = polyline.getPoint(_i).getCoords()
        _p2x, _p2y = polyline.getPoint(_i + 1).getCoords()
        if abs(_p2x - _p1x) < 1e-10: # vertical
            if (abs(_p2x - _px) < 1e-10 and
                min(_p1y, _p2y) < _py < max(_p1y, _p2y)):
                _hit = True
        elif abs(_p2y - _p1y) < 1e-10: # horizontal
            if (abs(_p2y - _py) < 1e-10 and
                min(_p1x, _p2x) < _px < max(_p1x, _p2x)):
                _hit = True
        else:
            _slope = (_p2y - _p1y)/(_p2x - _p1x)
            _yint = _p2y - (_slope * _p2x)
            _ytest = (_slope * _px) + _yint
            if abs(_ytest - _py) < 1e-10:
                _hit = True
        if _hit:
            polyline.addPoint((_i + 1), pt)
            break

class SplitManager(object):
    def __init__(self, layer):
        if not isinstance(layer, Layer):
            raise TypeError, "Invalid Layer: " + `type(layer)`
        self.__layer = layer
        self.__segs = []
        self.__circs = []
        self.__arcs = []
        self.__plines = []
        self.__rects = {}

    def segBounds(s):
        if not isinstance(s, Segment):
            raise TypeError, "Invalid Segment: " + `type(s)`
        _p1, _p2 = s.getEndpoints()
        _x, _y = _p1.getCoords()
        _xmin = _xmax = _x
        _ymin = _ymax = _y
        _x, _y = _p2.getCoords()
        if _x < _xmin:
            _xmin = _x
        if _y < _ymin:
            _ymin = _y
        if _x > _xmax:
            _xmax = _x
        if _y > _ymax:
            _ymax = _y
        return _xmin, _ymin, _xmax, _ymax

    segBounds = staticmethod(segBounds)

    def circBounds(c):
        if not isinstance(c, Circle):
            raise TypeError, "Invalid Circle: " + `type(c)`
        _x, _y = c.getCenter().getCoords()
        _r = c.getRadius()
        return ((_x - _r), (_y - _r), (_x + _r), (_y + _r))

    circBounds = staticmethod(circBounds)

    def canIntersect(r1, r2):
        if not isinstance(r1, tuple):
            raise TypeError, "Invalid R1 tuple: " + `type(r1)`
        if len(r1) != 4:
            raise ValueError, "R1 length error: " + str(r1)
        if not isinstance(r2, tuple):
            raise TypeError, "Invalid R2 tuple: " + `type(r2)`
        if len(r2) != 4:
            raise ValueError, "R2 length error: " + str(r2)
        return not ((r1[2] < r2[0]) or # r1 xmax < r2 xmin
                    (r1[0] > r2[2]) or # r1 xmin > r2 xmax
                    (r1[3] < r2[1]) or # r1 ymax < r2 ymin
                    (r1[1] > r2[3])) # r1 ymin > r2 ymax

    canIntersect = staticmethod(canIntersect)

    def splitSegTwoPts(seg, pt1, pt2):
        _p1, _p2 = seg.getEndpoints()
        _s = seg.getStyle()
        _l = seg.getLinetype()
        _c = seg.getColor()
        _t = seg.getThickness()
        _s1 = Segment(_p1, pt1, _s, _l, _c, _t)
        _s2 = Segment(pt1, pt2, _s, _l, _c, _t)
        _s3 = Segment(pt2, _p2, _s, _l, _c, _t)
        return _s1, _s2, _s3

    splitSegTwoPts = staticmethod(splitSegTwoPts)

    def splitCircTwoPts(circ, p1, p2):
        _cp = circ.getCenter()
        _r = circ.getRadius()
        _cx, _cy = _cp.getCoords()
        _px, _py = p1.getCoords()
        _a1 = _rtd * math.atan2((_py - _cy),(_px - _cx))
        if _a1 < 0.0:
            _a1 = _a1 + 360.0
        _px, _py = p2.getCoords()
        _a2 = _rtd * math.atan2((_py - _cy),(_px - _cx))
        if _a2 < 0.0:
            _a2 = _a2 + 360.0
        _s = circ.getStyle()
        _c = circ.getColor()
        _l = circ.getLinetype()
        _t = circ.getThickness()
        _arc1 = Arc(_cp, _r, _a1, _a2, _s, _l, _c, _t)
        _arc2 = Arc(_cp, _r, _a2, _a1, _s, _l, _c, _t)
        return _arc1, _arc2

    splitCircTwoPts = staticmethod(splitCircTwoPts)

    def splitArcTwoPts(arc, p1, p2):
        _cp = arc.getCenter()
        _r = arc.getRadius()
        _sa = arc.getStartAngle()
        _ea = arc.getEndAngle()
        _cx, _cy = _cp.getCoords()
        _px, _py = p1.getCoords()
        _ap1 = _rtd * math.atan2((_py - _cy), (_px - _cx))
        if _ap1 < 0.0:
            _ap1 = _ap1 + 360.0
        _px, _py = p2.getCoords()
        _ap2 = _rtd * math.atan2((_py - _cy), (_px - _cx))
        if _ap2 < 0.0:
            _ap2 = _ap2 + 360.0
        if _sa < _ea:
            _a1 = min(_ap1, _ap2)
            _a2 = max(_ap1, _ap2)
        else:
            _d1 = _ap1 - _sa
            if _d1 < 0.0:
                _d1 = _ap1 + _sa
            _d2 = _ap2 - _sa
            if _d2 < 0.0:
                _d2 = _ap2 + _sa
            if _d1 < _d2:
                _a1 = _ap1
                _a2 = _ap2
            else:
                _a1 = _ap2
                _a2 = _ap1
        _s = arc.getStyle()
        _l = arc.getLinetype()
        _c = arc.getColor()
        _t = arc.getThickness()
        _arc1 = Arc(_cp, _r, _sa, _a1, _s, _l, _c, _t)
        _arc2 = Arc(_cp, _r, _a1, _a2, _s, _l, _c, _t)
        _arc3 = Arc(_cp, _r, _a2, _ea, _s, _l, _c, _t)
        return _arc1, _arc2, _arc3

    splitArcTwoPts = staticmethod(splitArcTwoPts)
    
    def addObject(self, obj):
        if obj.getParent() is not self.__layer:
            raise ValueError, "Invalid object parent: " + `obj`
        _olist = None
        if isinstance(obj, Segment):
            _olist = self.__segs
        elif isinstance(obj, Circle):
            _olist = self.__circs
        elif isinstance(obj, Arc):
            _olist = self.__arcs
        elif isinstance(obj, Polyline):
            _olist = self.__plines
        else:
            raise TypeError, "Unexpected object: " + `type(obj)`
        _seen = False
        for _obj in _olist:
            if _obj is obj:
                _seen = True
                break
        if _seen:
            raise RuntimeError, "Object already stored: " + `obj`
        _olist.append(obj)

    def delObject(self, obj):
        _olist = None
        if isinstance(obj, Segment):
            _olist = self.__segs
        elif isinstance(obj, Circle):
            _olist = self.__circs
        elif isinstance(obj, Arc):
            _olist = self.__arcs
        elif isinstance(obj, Polyline):
            _olist= self.__plines
        else:
            raise TypeError, "Unexpected object: " + `type(obj)`
        for _i in range(len(_olist)):
            if _olist[_i] is obj:
                del _olist[_i]
                break

    def getSegments(self):
        return self.__segs

    def getCircles(self):
        return self.__circs

    def getArcs(self):
        return self.__arcs

    def getPolylines(self):
        return self.__plines

    def splitObjects(self):
        if len(self.__segs):
            self.__splitSegSeg()
            if len(self.__circs):
                self.__splitSegCircle()
            if len(self.__arcs):
                self.__splitSegArc()
            if len(self.__plines):
                self.__splitSegPolyline()
        if len(self.__circs):
            self.__splitCircCirc()
        if len(self.__circs) and len(self.__arcs):
            self.__splitCircArc()
        if len(self.__circs) and len(self.__plines):
            self.__splitCircPolyline()
        if len(self.__arcs):
            self.__splitArcArc()
            if len(self.__plines):
                self.__splitArcPolyline()
        if len(self.__plines):
            self.__splitPolyPoly()

    def __getPoint(self, x, y):
        _layer = self.__layer
        _pts = _layer.find('point', x, y)
        if len(_pts) == 0:
            _ip = Point(x, y)
            _layer.setAutosplit(False)
            _layer.addObject(_ip)
        else:
            _ip = _most_used(_pts)
        return _ip

    def __splitSegSeg(self):
        _layer = self.__layer
        _segs = self.__segs
        _rects = self.__rects
        _slist = []
        _sdict = {}
        while len(_segs):
            _seg = _segs.pop()
            _slist.append(_seg)
            _segid = id(_seg)
            if _segid in _sdict and not _sdict[_segid]:
                continue
            _p1, _p2 = _seg.getEndpoints()
            if (_p1.getParent() is not _layer or
                _p2.getParent() is not _layer):
                raise RuntimeError, "Invalid Segment endpoints: " + `_seg`
            _sdict[_segid] = True
            _rseg = _rects.get(_segid)
            if _rseg is None:
                _rseg = SplitManager.segBounds(_seg)
                _rects[_segid] = _rseg
            for _s in _segs:
                _sid = id(_s)
                if _sid in _sdict and not _sdict[_sid]:
                    continue
                _p3, _p4 = _s.getEndpoints()
                if (_p3.getParent() is not _layer or
                    _p4.getParent() is not _layer):
                    raise RuntimeError, "Invalid Segment endpoints: " + `_s`
                if _p1 == _p3 or _p1 == _p4 or _p2 == _p3 or _p2 == _p4:
                    continue
                _rs = _rects.get(_sid)
                if _rs is None:
                    _rs = SplitManager.segBounds(_s)
                    _rects[_sid] = _rs
                if not SplitManager.canIntersect(_rseg, _rs):
                    continue
                _ipts = intersections.find_intersections(_s, _seg)
                if len(_ipts):
                    _x, _y = _ipts[0]
                    _ip = self.__getPoint(_x, _y)
                    if _ip != _p1 and _ip != _p2:
                        _s1, _s2 = split_segment(_seg, _ip)
                        _segs.append(_s1)
                        _segs.append(_s2)
                        _sdict[_segid] = False
                    if _ip != _p3 and _ip != _p4:
                        _s1, _s2 = split_segment(_s, _ip)
                        _segs.append(_s1)
                        _segs.append(_s2)
                        _sdict[_sid] = False
                    break
        _nseg = []
        _dseg = []
        for _seg in _slist:
            _status = _sdict.get(id(_seg))
            if _status is None:
                raise RuntimeError, "No status for Segment: " + `_seg`
            elif _status:
                _nseg.append(_seg)
            else:
                _dseg.append(_seg)
        for _seg in _nseg:
            if _seg.getParent() is None:
                _layer.addObject(_seg)
        for _seg in _dseg:
            del self.__rects[id(_seg)]
            if _seg.getParent() is not None:
                _layer.delObject(_seg)
            else:
                _seg.finish()
        self.__segs = _nseg

    def __splitSegCircle(self):
        _segs = self.__segs
        _circs = self.__circs
        _layer = self.__layer
        _rects = self.__rects
        _slist = []
        _alist = []
        _odict = {}
        while len(_segs):
            _seg = _segs.pop()
            _slist.append(_seg)
            _sid = id(_seg)
            if _sid in _odict and not _odict[_sid]:
                continue
            _p1, _p2 = _seg.getEndpoints()
            if (_p1.getParent() is not _layer or
                _p2.getParent() is not _layer):
                raise RuntimeError, "Invalid Segment endpoints: " + `_seg`
            _odict[_sid] = True
            _rs = _rects.get(_sid)
            if _rs is None:
                _rs = SplitManager.segBounds(_seg)
                _rects[_sid] = _rs
            for _circ in _circs:
                _cid = id(_circ)
                if _cid in _odict and not _odict[_cid]:
                    continue
                _odict[_cid] = True
                _rc = _rects.get(_cid)
                if _rc is None:
                    _rc = SplitManager.circBounds(_circ)
                    _rects[_cid] = _rc
                if not SplitManager.canIntersect(_rs, _rc):
                    continue
                _ipts = intersections.find_intersections(_seg, _circ)
                if len(_ipts):
                    _s1 = _s2 = _s3 = _a1 = _a2 = None
                    _p1, _p2 = _seg.getEndpoints()
                    _count = len(_ipts)
                    if _count == 1:
                        _x, _y = _ipts[0]
                        _ip = self.__getPoint(_x, _y)
                        _a1 = split_circle(_circ, _ip)
                        if _ip != _p1 and _ip != _p2:
                            _s1, _s2 = split_segment(_seg, _ip)
                    elif _count == 2:
                        _x, _y = _ipts[0]
                        _ip1 = self.__getPoint(_x, _y)
                        _x, _y = _ipts[1]
                        _ip2 = self.__getPoint(_x, _y)
                        _a1, _a2 = SplitManager.splitCircTwoPts(_circ, _ip1, _ip2)
                        if (_ip1 != _p1 and
                            _ip1 != _p2 and
                            _ip2 != _p1 and
                            _ip2 != _p2):
                            if ((_p1 - _ip1) < (_p1 - _ip2)):
                                _m1 = _ip1
                                _m2 = _ip2
                            else:
                                _m1 = _ip2
                                _m2 = _ip1
                            _s1, _s2, _s3 = SplitManager.splitSegTwoPts(_seg, _m1, _m2)
                        elif ((_ip1 == _p1 or _ip1 == _p2) and
                              (_ip2 != _p1 and _ip2 != _p2)):
                            _s1, _s2 = split_segment(_seg, _ip2)
                        elif ((_ip2 == _p1 or _ip2 == _p2) and
                              (_ip1 != _p1 and _ip1 != _p2)):
                            _s1, _s2 = split_segment(_seg, _ip1)
                        else:
                            pass
                    else:
                        raise ValueError, "Unexpected count: %d" % _count
                    #
                    # if _s1 is not None the segment was split
                    #
                    if _s1 is not None:
                        _odict[_sid] = False
                        _segs.append(_s1)
                    if _s2 is not None:
                        _segs.append(_s2)
                    if _s3 is not None:
                        _segs.append(_s3)
                    #
                    # if _a1 is not None the circle was split
                    #
                    if _a1 is not None:
                        _odict[_cid] = False
                        _alist.append(_a1)
                    if _a2 is not None:
                        _alist.append(_a2)
                    break
        #
        # handle arcs
        #
        for _obj in _alist:
            _layer.addObject(_obj)
            self.addObject(_obj)
        #
        # handle circles
        #
        _dcirc = []
        for _obj in _circs:
            _oid = id(_obj)
            _status = _odict.get(_oid)
            if _status is None:
                raise RuntimeError, "No status for Circle: " + `_obj`
            else:
                if not _status:
                    _dcirc.append(_obj)
        for _obj in _dcirc:
            self.delObject(_obj)
            del self.__rects[id(_obj)]
            _layer.delObject(_obj)
        #
        # handle segments
        #
        _nseg = []
        _dseg = []
        for _obj in _slist:
            _status = _odict.get(id(_obj))
            if _status is None:
                raise RuntimeError, "No status for Segment: " + `_obj`
            elif _status:
                _nseg.append(_obj)
            else:
                _dseg.append(_obj)
        for _obj in _nseg:
            if _obj.getParent() is None:
                _layer.addObject(_obj)
        for _obj in _dseg:
            del self.__rects[id(_obj)]
            if _obj.getParent() is not None:
                _layer.delObject(_obj)
            else:
                _obj.finish()
        self.__segs = _nseg

    def __splitSegArc(self):
        _segs = self.__segs
        _arcs = self.__arcs
        _layer = self.__layer
        _rects = self.__rects
        _slist = []
        _odict = {}
        while len(_segs):
            _seg = _segs.pop()
            _slist.append(_seg)
            _sid = id(_seg)
            if _sid in _odict and not _odict[_sid]:
                continue
            _p1, _p2 = _seg.getEndpoints()
            if (_p1.getParent() is not _layer or
                _p2.getParent() is not _layer):
                raise RuntimeError, "Invalid Segment endpoints: " + `_seg`
            _odict[_sid] = True
            _rs = _rects.get(_sid)
            if _rs is None:
                _rs = SplitManager.segBounds(_seg)
                _rects[_sid] = _rs
            for _arc in _arcs:
                _aid = id(_arc)
                if _aid in _odict and not _odict[_aid]:
                    continue
                _odict[_aid] = True
                _ra = _rects.get(_aid)
                if _ra is None:
                    _ra = _arc.getBounds()
                    _rects[_aid] = _ra
                if not SplitManager.canIntersect(_rs, _ra):
                    continue
                _ipts = intersections.find_intersections(_seg, _arc)
                if len(_ipts):
                    _s1 = _s2 = _s3 = _a1 = _a2 = _a3 = None
                    _p1, _p2 = _seg.getEndpoints()
                    _ep1, _ep2 = _arc.getEndpoints()
                    _count = len(_ipts)
                    if _count == 1:
                        _x, _y = _ipts[0]
                        _ip = self.__getPoint(_x, _y)
                        if _ip != _ep1 and _ip != _ep2:
                            _a1, _a2 = split_arc(_arc, _ip)
                        if _ip != _p1 and _ip != _p2:
                            _s1, _s2 = split_segment(_seg, _ip)
                    elif _count == 2:
                        _x, _y = _ipts[0]
                        _ip1 = self.__getPoint(_x, _y)
                        _x, _y = _ipts[1]
                        _ip2 = self.__getPoint(_x, _y)
                        if (_ip1 != _ep1 and
                            _ip1 != _ep2 and
                            _ip2 != _ep1 and
                            _ip2 != _ep2):
                            _a1, _a2, _a3 = SplitManager.splitArcTwoPts(_arc, _ip1, _ip2)
                        elif ((_ip1 == _ep1 or _ip1 == _ep2) and
                              (_ip2 != _ep1 and _ip2 != _ep2)):
                            _a1, _a2 = split_arc(_arc, _ip2)
                        elif ((_ip2 == _ep1 or _ip2 == _ep2) and
                              (_ip1 != _ep1 and _ip1 != _ep2)):
                            _a1, _a2 = split_arc(_arc, _ip1)
                        else:
                            pass
                        if (_ip1 != _p1 and
                            _ip1 != _p2 and
                            _ip2 != _p1 and
                            _ip2 != _p2):
                            if ((_p1 - _ip1) < (_p1 - _ip2)):
                                _m1 = _ip1
                                _m2 = _ip2
                            else:
                                _m1 = _ip2
                                _m2 = _ip1
                            _s1, _s2, _s3 = SplitManager.splitSegTwoPts(_seg, _m1, _m2)
                        elif ((_ip1 == _p1 or _ip1 == _p2) and
                              (_ip2 != _p1 and _ip2 != _p2)):
                            _s1, _s2 = split_segment(_seg, _ip2)
                        elif ((_ip2 == _p1 or _ip2 == _p2) and
                              (_ip1 != _p1 and _ip1 != _p2)):
                            _s1, _s2 = split_segment(_seg, _ip1)
                        else:
                            pass
                    else:
                        raise ValueError, "Unexpected count: %d" % _count
                    #
                    # if _s1 is not None the segment was split
                    #
                    if _s1 is not None:
                        _odict[_sid] = False
                        _segs.append(_s1)
                    if _s2 is not None:
                        _segs.append(_s2)
                    if _s3 is not None:
                        _segs.append(_s3)
                    #
                    # if _a1 is not None the arc was split
                    #
                    if _a1 is not None:
                        _odict[_aid] = False
                        _arcs.append(_a1)
                    if _a2 is not None:
                        _arcs.append(_a2)
                    if _a3 is not None:
                        _arcs.append(_a3)
                    break
        #
        # handle arcs
        #
        _narc = []
        _darc = []
        for _obj in _arcs:
            _status = _odict.get(id(_obj))
            if _status is None:
                raise RuntimeError, "No status for Arc: " + `_obj`
            elif _status:
                _narc.append(_obj)
            else:
                _darc.append(_obj)
        for _obj in _narc:
            if _obj.getParent() is None:
                _layer.addObject(_obj)
        for _obj in _darc:
            del self.__rects[id(_obj)]
            if _obj.getParent() is not None:
                _layer.delObject(_obj)
            else:
                _obj.finish()
        self.__arcs = _narc
        #
        # handle segments
        #
        _nseg = []
        _dseg = []
        for _obj in _slist:
            _status = _odict.get(id(_obj))
            if _status is None:
                raise RuntimeError, "No status for Segment: " + `_obj`
            elif _status:
                _nseg.append(_obj)
            else:
                _dseg.append(_obj)
        for _obj in _nseg:
            if _obj.getParent() is None:
                _layer.addObject(_obj)
        for _obj in _dseg:
            del self.__rects[id(_obj)]
            if _obj.getParent() is not None:
                _layer.delObject(_obj)
            else:
                _obj.finish()
        self.__segs = _nseg

    def __splitSegPolyline(self):
        _segs = self.__segs
        _plines = self.__plines
        _layer = self.__layer
        _rects = self.__rects
        _slist = []
        _odict = {}
        while len(_segs):
            _seg = _segs.pop()
            _slist.append(_seg)
            _sid = id(_seg)
            if _sid in _odict and not _odict[_sid]:
                continue
            _p1, _p2 = _seg.getEndpoints()
            if (_p1.getParent() is not _layer or
                _p2.getParent() is not _layer):
                raise RuntimeError, "Invalid Segment endpoints: " + `_seg`
            _odict[_sid] = True
            _rs = _rects.get(_sid)
            if _rs is None:
                _rs = SplitManager.segBounds(_seg)
                _rects[_sid] = _rs
            _ip = None
            for _pl in _plines:
                _pid = id(_pl)
                _rp = _rects.get(_pid)
                if _rp is None:
                    _rp = _pl.getBounds()
                    _rects[_pid] = _rp
                if not SplitManager.canIntersect(_rs, _rp):
                    continue
                _pts = _pl.getPoints()
                for _i in range(len(_pts) - 1):
                    _lp1 = _pts[_i]
                    _lp2 = _pts[_i + 1]
                    if (_p1 == _lp1 or
                        _p1 == _lp2 or
                        _p2 == _lp1 or
                        _p2 == _lp2):
                        continue
                    _ts = Segment(_lp1, _lp2)
                    _ipts = intersections.find_intersections(_seg, _ts)
                    _ts.finish()
                    if len(_ipts):
                        _count = len(_ipts)
                        if _count == 1:
                            _x, _y = _ipts[0]
                            _ip = self.__getPoint(_x, _y)
                            _s1, _s2 = split_segment(_seg, _ip)
                            _odict[_sid] = False
                            _segs.append(_s1)
                            _segs.append(_s2)
                            _pl.addPoint((_i + 1), _ip)
                        else:
                            raise ValueError, "Unexpected count: %d" % _count
                    if _ip is not None:
                        break
                if _ip is not None:
                    break
        #
        # handle segments
        #
        _nseg = []
        _dseg = []
        for _obj in _slist:
            _status = _odict.get(id(_obj))
            if _status is None:
                raise RuntimeError, "No status for Segment: " + `_obj`
            elif _status:
                _nseg.append(_obj)
            else:
                _dseg.append(_obj)
        for _obj in _nseg:
            if _obj.getParent() is None:
                _layer.addObject(_obj)
        for _obj in _dseg:
            del self.__rects[id(_obj)]
            if _obj.getParent() is not None:
                _layer.delObject(_obj)
            else:
                _obj.finish()
        self.__segs = _nseg

    def __splitCircCirc(self):
        _layer = self.__layer
        _circs = self.__circs
        _rects = self.__rects
        _olist = []
        _cdict = {}
        while len(_circs):
            _circ = _circs.pop()
            _olist.append(_circ)
            _circid = id(_circ)
            if _circid in _cdict and not _cdict[_circid]:
                continue
            _cdict[_circid] = True
            _rcirc = _rects.get(_circid)
            if _rcirc is None:
                _rcirc = SplitManager.circBounds(_circ)
                _rects[_circid] = _rcirc
            for _c in _circs:
                _cid = id(_c)
                if _cid in _cdict and not _cdict[_cid]:
                    continue
                _rc = _rects.get(_cid)
                if _rc is None:
                    _rc = SplitManager.circBounds(_c)
                    _rects[_cid] = _rc
                if not SplitManager.canIntersect(_rcirc, _rc):
                    continue
                _ipts = intersections.find_intersections(_c, _circ)
                if len(_ipts):
                    _count = len(_ipts)
                    if _count == 1:
                        _x, _y = _ipts[0]
                        _ip = self.__getPoint(_x, _y)
                        _arc = split_circle(_circ, _ip)
                        _olist.append(_arc)
                        _cdict[_circid] = False
                        _arc = split_circle(_c, _ip)
                        _olist.append(_arc)
                        _cdict[_cid] = False
                    elif _count == 2:
                        _x, _y = _ipts[0]
                        _ip1 = self.__getPoint(_x, _y)
                        _x, _y = _ipts[1]
                        _ip2 = self.__getPoint(_x, _y)
                        _arc1, _arc2 = SplitManager.splitCircTwoPts(_circ, _ip1, _ip2)
                        _cdict[_circid] = False
                        _olist.append(_arc1)
                        _olist.append(_arc2)
                        _arc1, _arc2 = SplitManager.splitCircTwoPts(_c, _ip1, _ip2)
                        _olist.append(_arc1)
                        _olist.append(_arc2)
                        _cdict[_cid] = False
                    else:
                        raise ValueError, "Unexpected count: %d" % _count
                    break
        _dlist = []
        for _obj in _olist:
            _status = _cdict.get(id(_obj))
            if _status is None:
                _layer.addObject(_obj)
                self.addObject(_obj)
            elif _status:
                _circs.append(_obj)
            else:
                _dlist.append(_obj)
        for _obj in _dlist:
            self.delObject(_obj)
            del self.__rects[id(_obj)]
            _layer.delObject(_obj)

    def __splitCircArc(self):
        _layer = self.__layer
        _circs = self.__circs
        _arcs = self.__arcs
        _rects = self.__rects
        _clist = []
        _odict = {}
        while len(_circs):
            _circ = _circs.pop()
            _clist.append(_circ)
            _circid = id(_circ)
            if _circid in _odict and not _odict[_circid]:
                continue
            _odict[_circid] = True
            _rcirc = _rects.get(_circid)
            if _rcirc is None:
                _rcirc = SplitManager.circBounds(_circ)
                _rects[_circid] = _rcirc
            for _arc in _arcs:
                _arcid = id(_arc)
                if _arcid in _odict and not _odict[_arcid]:
                    continue
                _odict[_arcid] = True
                _rarc = _rects.get(_arcid)
                if _rarc is None:
                    _rarc = _arc.getBounds()
                    _rects[_arcid] = _rarc
                if not SplitManager.canIntersect(_rcirc, _rarc):
                    continue
                _ipts = intersections.find_intersections(_circ, _arc)
                if len(_ipts):
                    _ep1, _ep2 = _arc.getEndpoints()
                    _ca1 = _ca2 = _a1 = _a2 = _a3 = None
                    _count = len(_ipts)
                    if _count == 1:
                        _x, _y = _ipts[0]
                        _ip = self.__getPoint(_x, _y)
                        _ca1 = split_circle(_circ, _ip)
                        if _ip != _ep1 and _ip != _ep2:
                            _a1, _a2 = split_arc(_arc, _ip)
                    elif _count == 2:
                        _x, _y = _ipts[0]
                        _ip1 = self.__getPoint(_x, _y)
                        _x, _y = _ipts[1]
                        _ip2 = self.__getPoint(_x, _y)
                        _ca1, _ca2 = SplitManager.splitCircTwoPts(_circ, _ip1, _ip2)
                        if (_ip1 != _ep1 and
                            _ip1 != _ep2 and
                            _ip2 != _ep1 and
                            _ip2 != _ep2):
                            _a1, _a2, _a3 = SplitManager.splitArcTwoPts(_arc, _ip1, _ip2)
                        elif ((_ip1 == _ep1 or _ip1 == _ep2) and
                              (_ip2 != _ep1 and _ip2 != _ep2)):
                            _a1, _a2 = split_arc(_arc, _ip2)
                        elif ((_ip2 == _ep1 or _ip2 == _ep2) and
                              (_ip1 !=_ep1 and _ip1 != _ep2)):
                            _a1, _a2 = split_arc(_arc, _ip1)
                        else:
                            pass
                    else:
                        raise ValueError, "Unexpected count: %d" % _count
                    #
                    # if _ca1 is not none then the circle was split
                    #
                    if _ca1 is not None:
                        _odict[_circid] = False
                        _arcs.append(_ca1)
                    if _ca2 is not None:
                        _arcs.append(_ca2)
                    #
                    # if _a1 is not None then the arc was split
                    #
                    if _a1 is not None:
                        _odict[_arcid] = False
                        _arcs.append(_a1)
                    if _a2 is not None:
                        _arcs.append(_a2)
                    if _a3 is not None:
                        _arcs.append(_a3)
                    if _ca1 is not None or _a1 is not None:
                        break
        #
        # handle arcs
        #
        _narc = []
        _darc = []
        for _obj in _arcs:
            _status = _odict.get(id(_obj))
            #
            # states:
            # None - Arc untested - created during split of final circle
            # True - Arc survived all split attempts
            # False - Arc was split
            #
            if _status is None or _status:
                _narc.append(_obj)
            else:
                _darc.append(_obj)
        for _obj in _narc:
            if _obj.getParent() is None:
                _layer.addObject(_obj)
        for _obj in _darc:
            del self.__rects[id(_obj)]
            if _obj.getParent() is not None:
                _layer.delObject(_obj)
            else:
                _obj.finish()
        self.__arcs = _narc
        #
        # handle circles
        #
        _dlist = []
        for _obj in _clist:
            _status = _odict.get(id(_obj))
            if _status is None:
                raise RuntimeError, "No status for Circle: " + `_obj`
            elif _status:
                _circs.append(_obj)
            else:
                _dlist.append(_obj)
        for _obj in _dlist:
            self.delObject(_obj)
            del self.__rects[id(_obj)]
            _layer.delObject(_obj)

    def __splitCircPolyline(self):
        _circs = self.__circs
        _plines = self.__plines
        _layer = self.__layer
        _rects = self.__rects
        _alist = []
        _clist = []
        _odict = {}
        while len(_circs):
            _circ = _circs.pop()
            _clist.append(_circ)
            _circid = id(_circ)
            if _circid in _odict and not _odict[_circid]:
                continue
            _odict[_circid] = True
            _rcirc = _rects.get(_circid)
            if _rcirc is None:
                _rcirc = SplitManager.circBounds(_circ)
                _rects[_circid] = _rcirc
            _hit = False                
            for _pl in _plines:
                _pid = id(_pl)
                _rp = _rects.get(_pid)
                if _rp is None:
                    _rp = _pl.getBounds()
                    _rects[_pid] = _rp
                if not SplitManager.canIntersect(_rcirc, _rp):
                    continue
                _pts = _pl.getPoints()
                for _i in range(len(_pts) - 1):
                    _lp1 = _pts[_i]
                    _lp2 = _pts[_i + 1]
                    _seg = Segment(_lp1, _lp2)
                    _ipts = intersections.find_intersections(_circ, _seg)
                    _seg.finish()
                    if len(_ipts):
                        _hit = True
                        _a1 = _a2 = None
                        _count = len(_ipts)
                        if _count == 1:
                            _x, _y = _ipts[0]
                            _ip = self.__getPoint(_x, _y)
                            _a1 = split_circle(_circ, _ip)
                            if _ip != _lp1 and _ip != _lp2:
                                _pl.addPoint((_i + 1), _ip)
                        elif _count == 2:
                            _x, _y = _ipts[0]
                            _ip1 = self.__getPoint(_x, _y)
                            _x, _y = _ipts[1]
                            _ip2 = self.__getPoint(_x, _y)
                            _a1, _a2 = SplitManager.splitCircTwoPts(_circ, _ip1, _ip2)
                            if (_ip1 - _lp1) < (_ip2 - _lp1):
                                _p1 = _ip1
                                _p2 = _ip2
                            else:
                                _p1 = _ip2
                                _p2 = _ip1
                            if _p1 != _lp1 and _p1 != _lp2:
                                _pl.addPoint((_i + 1), _p1)
                                _i = _i + 1
                            if _p2 != _lp1 and _p2 != _lp2:
                                _pl.addPoint((_i + 1), _p2)
                        else:
                            raise ValueError, "Unexpected count: %d" % _count
                        #
                        # if _a1 is not None the circle was split
                        #
                        if _a1 is not None:
                            _odict[_circid] = False
                            _alist.append(_a1)
                        if _a2 is not None:
                            _alist.append(_a2)
                        break
                if _hit:
                    break
        #
        # handle arcs
        #
        for _obj in _alist:
            _layer.addObject(_obj)
            self.addObject(_obj)
        #
        # handle circles
        #
        _dlist = []
        for _obj in _clist:
            _status = _odict.get(id(_obj))
            if _status is None:
                raise RuntimeError, "No status for Circle: " + `_obj`
            elif _status:
                _circs.append(_obj)
            else:
                _dlist.append(_obj)
        for _obj in _dlist:
            self.delObject(_obj)
            del self.__rects[id(_obj)]
            _layer.delObject(_obj)

    def printArcs(self, a1, a2):
        print "Arc1: "
        print "Center: " + str(a1.getCenter().getCoords())
        print "Radius: %f" % a1.getRadius()
        _ep1, _ep2 = a1.getEndpoints()
        print "SA: %f, EP: %s" % (a1.getStartAngle(), str(_ep1))
        print "EA: %f, EP: %s" % (a1.getEndAngle(), str(_ep2))
        print "Arc2: "
        print "Center: " + str(a2.getCenter().getCoords())
        print "Radius: %f" % a2.getRadius()
        _ep1, _ep2 = a2.getEndpoints()
        print "SA: %f, EP: %s" % (a2.getStartAngle(), str(_ep1))
        print "EA: %f, EP: %s" % (a2.getEndAngle(), str(_ep2))

    def __splitArcArc(self):
        _arcs = self.__arcs
        _layer = self.__layer
        _rects = self.__rects
        _alist = []
        _adict = {}
        while len(_arcs):
            _arc = _arcs.pop()
            _alist.append(_arc)
            _arcid = id(_arc)
            if _arcid in _adict and not _adict[_arcid]:
                continue
            _adict[_arcid] = True
            _rarc = _rects.get(_arcid)
            if _rarc is None:
                _rarc = _arc.getBounds()
                _rects[_arcid] = _rarc
            _ep1, _ep2 = _arc.getEndpoints()
            for _a in _arcs:
                _aid = id(_a)
                if _aid in _adict and not _adict[_aid]:
                    continue
                _ra = _rects.get(_aid)
                if _ra is None:
                    _ra = _a.getBounds()
                    _rects[_aid] = _ra
                if not SplitManager.canIntersect(_rarc, _ra):
                    continue
                _ep3, _ep4 = _a.getEndpoints()
                _ipts = intersections.find_intersections(_arc, _a)
                if len(_ipts):
                    _a1 = _a2 = _a3 = _a4 = _a5 = _a6 = None
                    _count = len(_ipts)
                    if _count == 1:
                        _x, _y = _ipts[0]
                        _ip = self.__getPoint(_x, _y)
                        if _ip != _ep1 and _ip != _ep2:
                            _a1, _a2 = split_arc(_arc, _ip)
                        if _ip != _ep3 and _ip != _ep4:
                            _a4, _a5 = split_arc(_a, _ip)
                    elif _count == 2:
                        _x, _y = _ipts[0]
                        _ip1 = self.__getPoint(_x, _y)
                        _x, _y = _ipts[1]
                        _ip2 = self.__getPoint(_x, _y)
                        if (_ip1 != _ep1 and
                            _ip1 != _ep2 and
                            _ip2 != _ep1 and
                            _ip2 != _ep2):
                            _a1, _a2, _a3 = SplitManager.splitArcTwoPts(_arc, _ip1, _ip2)
                        elif ((_ip1 == _ep1 or _ip1 == _ep2) and
                              (_ip2 != _ep1 and _ip2 != _ep2)):
                            _a1, _a2 = split_arc(_arc, _ip2)
                        elif ((_ip2 == _ep1 or _ip2 == _ep2) and
                              (_ip1 != _ep1 and _ip1 != _ep2)):
                            _a1, _a2 = split_arc(_arc, _ip1)
                        else:
                            pass
                        if (_ip1 != _ep3 and
                            _ip1 != _ep4 and
                            _ip2 != _ep3 and
                            _ip2 != _ep4):
                            _a4, _a5, _a6 = SplitManager.splitArcTwoPts(_a, _ip1, _ip2)
                        elif ((_ip1 == _ep3 or _ip1 == _ep4) and
                              (_ip2 != _ep3 and _ip2 != _ep4)):
                            _a4, _a5 = split_arc(_a, _ip2)
                        elif ((_ip2 == _ep3 or _ip2 == _ep4) and
                              (_ip1 != _ep3 and _ip1 != _ep4)):
                            _a4, _a5 = split_arc(_a, _ip1)
                        else:
                            pass
                    else:
                        raise ValueError, "Unexpected count: %d" % _count
                    #
                    # if _a1 is not None then _arc was split
                    #
                    if _a1 is not None:
                        _adict[_arcid] = False
                        _arcs.append(_a1)
                    if _a2 is not None:
                        _arcs.append(_a2)
                    if _a3 is not None:
                        _arcs.append(_a3)
                    #
                    # if _a4 is not None then _a was split
                    #
                    if _a4 is not None:
                        _adict[_aid] = False
                        _arcs.append(_a4)
                    if _a5 is not None:
                        _arcs.append(_a5)
                    if _a6 is not None:
                        _arcs.append(_a6)
                    if _a1 is not None or _a4 is not None:
                        break
        _narc = []
        _darc = []
        for _arc in _alist:
            _status = _adict.get(id(_arc))
            if _status is None:
                raise RuntimeError, "No status for Arc: " + `_arc`
            elif _status:
                _narc.append(_arc)
            else:
                _darc.append(_arc)
        for _arc in _narc:
            if _arc.getParent() is None:
                _layer.addObject(_arc)
        for _arc in _darc:
            del self.__rects[id(_arc)]
            if _arc.getParent() is not None:
                _layer.delObject(_arc)
            else:
                _arc.finish()
        self.__arcs = _narc

    def __splitArcPolyline(self):
        _arcs = self.__arcs
        _plines = self.__plines
        _layer = self.__layer
        _rects = self.__rects
        _alist = []
        _adict = {}
        while len(_arcs):
            _arc = _arcs.pop()
            _alist.append(_arc)
            _arcid = id(_arc)
            if _arcid in _adict and not _adict[_arcid]:
                continue
            _adict[_arcid] = True
            _rarc = _rects.get(_arcid)
            if _rarc is None:
                _rarc = _arc.getBounds()
                _rects[_arcid] = _rarc
            _ep1, _ep2 = _arc.getEndpoints()
            _hit = False
            for _pl in _plines:
                _pid = id(_pl)
                _rp = _rects.get(_pid)
                if _rp is None:
                    _rp = _pl.getBounds()
                    _rects[_pid] = _rp
                if not SplitManager.canIntersect(_rarc, _rp):
                    continue
                _pts = _pl.getPoints()
                for _i in range(len(_pts) - 1):
                    _lp1 = _pts[_i]
                    _lp2 = _pts[_i + 1]
                    _seg = Segment(_lp1, _lp2)
                    _ipts = intersections.find_intersections(_arc, _seg)
                    _seg.finish()
                    if len(_ipts):
                        _a1 = _a2 = _a3 = None
                        _count = len(_ipts)
                        if _count == 1:
                            _x, _y = _ipts[0]
                            _ip = self.__getPoint(_x, _y)
                            if _ip != _ep1 and _ip != _ep2:
                                _hit = True
                                _a1, _a2 = split_arc(_arc, _ip)
                            if _ip != _lp1 and _ip != _lp2:
                                _hit = True
                                _pl.addPoint((_i + 1), _ip)
                        elif _count == 2:
                            _x, _y = _ipts[0]
                            _ip1 = self.__getPoint(_x, _y)
                            _x, _y = _ipts[1]
                            _ip2 = self.__getPoint(_x, _y)
                            if (_ip1 != _ep1 and
                                _ip1 != _ep2 and
                                _ip2 != _ep1 and
                                _ip2 != _ep2):
                                _hit = True
                                _a1, _a2, _a3 = SplitManager.splitArcTwoPts(_arc, _ip1, _ip2)
                            elif ((_ip1 == _ep1 or _ip1 == _ep2) and
                                  (_ip2 != _ep1 and _ip2 != _ep2)):
                                _hit = True
                                _a1, _a2 = split_arc(_arc, _ip2)
                            elif ((_ip2 == _ep1 or _ip2 == _ep2) and
                                  (_ip1 != _ep1 and _ip1 != _ep2)):
                                _hit = True
                                _a1, _a2 = split_arc(_arc, _ip1)
                            else:
                                pass
                            if (_lp1 - _ip1) < (_lp1 -_ip2):
                                _p1 = _ip1
                                _p2 = _ip2
                            else:
                                _p1 = _ip2
                                _p2 = _ip1
                            if _p1 != _lp1 and _p1 != _lp2:
                                _hit = True
                                _pl.addPoint((_i + 1), _p1)
                                _i = _i + 1
                            if _p2 != _lp1 and _p2 != _lp2:
                                _hit = True
                                _pl.addPoint((_i + 1), _p2)
                        else:
                            raise ValueError, "Unexpected count: %d" % _count
                        #
                        # if _a1 is not None then _arc was split
                        #
                        if _a1 is not None:
                            _adict[_arcid] = False
                            _arcs.append(_a1)
                        if _a2 is not None:
                            _arcs.append(_a2)
                        if _a3 is not None:
                            _arcs.append(_a3)
                    if _hit:
                        break
                if _hit:
                    break
        _narc = []
        _darc = []
        for _arc in _alist:
            _status = _adict.get(id(_arc))
            if _status is None:
                raise RuntimeError, "No status for Arc: " + `_arc`
            elif _status:
                _narc.append(_arc)
            else:
                _darc.append(_arc)
        for _arc in _narc:
            if _arc.getParent() is None:
                _layer.addObject(_arc)
        for _arc in _darc:
            del self.__rects[id(_arc)]
            if _arc.getParent() is not None:
                _layer.delObject(_arc)
            else:
                _arc.finish()
        self.__arcs = _narc

    def __splitPolyPoly(self):
        _plines = self.__plines
        _rects = self.__rects
        _pdict = {}
        while len(_plines):
            _pl = _plines.pop()
            _plid = id(_pl)
            if _plid in _pdict and not _pdict[_plid]:
                continue
            _pdict[_plid] = True
            _rpl = _rects.get(_plid)
            if _rpl is None:
                _rpl = _pl.getBounds()
                _rects[_plid] = _rpl
            _maxi = len(_pl) - 1
            _ip = None
            for _p in _plines:
                _pid = id(_p)
                if _pid in _pdict and not _pdict[_pid]:
                    continue
                _rp = _rects.get(_pid)
                if _rp is None:
                    _rp = _p.getBounds()
                    _rects[_pid] = _rp
                if not SplitManager.canIntersect(_rpl, _rp):
                    continue
                for _i in range(_maxi):
                    _p1 = _pl.getPoint(_i)
                    _p2 = _pl.getPoint(_i + 1)
                    _x1, _y1 = _p1.getCoords()
                    _x2, _y2 = _p2.getCoords()
                    _maxj = len(_p) - 1
                    for _j in range(_maxj):
                        _p3 = _p.getPoint(_j)
                        _p4 = _p.getPoint(_j + 1)
                        if (_p1 == _p3 or
                            _p1 == _p4 or
                            _p2 == _p3 or
                            _p2 == _p4):
                            continue
                        _d = intersections.denom(_p1, _p2, _p3, _p4)
                        if abs(_d) > 1e-10: # NOT parallel
                            _rn = intersections.rnum(_p1, _p2, _p3, _p4)
                            if abs(_rn) > 1e-10: # NOT colinear
                                _sn = intersections.snum(_p1, _p2, _p3 ,_p4)
                                _r = _rn/_d
                                _s = _sn/_d
                                if ((0.0 < _r < 1.0) and (0.0 < _s < 1.0)):
                                    _xi = _x1 + _r * (_x2 - _x1)
                                    _yi = _y1 + _r * (_y2 - _y1)
                                    _ip = self.__getPoint(_xi, _yi)
                                    _pl.addPoint((_i + 1), _ip)
                                    _p.addPoint((_j + 1), _ip)
                        if _ip is not None:
                            break
                    if _ip is not None:
                        break
                if _ip is not None:
                    break
            if _ip is not None:
                _plines.append(_pl)

def split_objects(objlist):
    """Split a list of objects at their intersection points.

split_objects(objlist):

objlist: A list or tuple of objects to split
    """
    if not isinstance(objlist, (list, tuple)):
        raise TypeError, "Invalid object list/tuple: " + `type(objlist)`
    _ldict = {}
    for _obj in objlist:
        _layer = _obj.getParent()
        if _layer is not None:
            _mgr = _ldict.setdefault(id(_layer), SplitManager(_layer))
            _mgr.addObject(_obj)
    for _mgr in _ldict.values():
        _mgr.splitObjects()
