#
# Copyright (c) 2002, 2003 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
#
#
# hatching code
#

import math
import point
import segment
import circle
import arc
import segjoint
import layer

class Path(object):
    """The class for maintaining a list of objects defining a hatch border.

A Path object contains one or more objects defining the boundary
of a hatching. If the Path length is 1, the boundary is either a
circle or an arc where the start angle and end angle are equal.
There is no upper limit to the number of objects in the path.

If a Path consists of Segments, Arcs, Chamfer, or Fillets, the
Path can only be valid if starting at any point in any object
in the Path the connections between the objects lead back to the
starting point.

A Path has the following methods:

isExternal(): Check if the Path is an outer boundary
isCircular(): Check if the Path is a Circle or closed Arc.
getPath(): Return the objects comprising the Path
inPath(): Test if a coordinate is inside a Path.
    """
    def __init__(self, objs, external=True):
        """Initialize a Path.

p = Path(objs[, external])

The required argument "objs" is a list of objects defining
the path. The valid objects are circles, arcs, segments,
chamfers and fillets.

The optional argument "external" is by default True, meaning
that this Path is an outer boundary. If the argument is False,
then the Path represents an internal non-hatched area inside
another Path.
        """
        if not isinstance(objs, list):
            raise TypeError, "Invalid object list: " + `objs`
        if not len(objs):
            raise ValueError, "Invalid empty object list"
        for _obj in objs:
            _valid = False
            if (isinstance(_obj, segment.Segment) or
                isinstance(_obj, arc.Arc) or
                isinstance(_obj, circle.Circle) or
                isinstance(_obj, segjoint.Chamfer) or
                isinstance(_obj, segjoint.Fillet)):
                _valid = True
            if not _valid:
                raise TypeError, "Invalid object in object list: " + `_obj`
        _circular = False
        if len(objs) == 1:
            _circular = True
            _obj = objs[0]
            _valid = False
            if isinstance(_obj, arc.Arc):
                _sa = _obj.getStartAngle()
                _ea = _obj.getEndAngle()
                if abs(_sa - _ea) < 1e-10:
                    _valid = True
                if not _valid:
                    raise TypeError, "Invalid single Arc path: " + str(_obj)
            elif isinstance(_obj, circle.Circle):
                pass
            else:
                raise TypeError, "Invalid single entity path: " + str(_obj)
        else:
            _valid = True
            for _obj in objs:
                if isinstance(_obj, circle.Circle):
                    if not isinstance(_obj, arc.Arc):
                        _valid = False
                        break
            if not _valid:
                raise TypeError, "Circle found in multi-object path"
            _valid = True # _validate_path(objlist)
            if not _valid:
                raise ValueError, "Objlist objects do not make a closed path."
        if external is not True and external is not False:
            raise ValueError, "Invalid external flag: " + `external`
        self.__objs = objs[:]
        self.__circular = _circular
        self.__external = external

    def __len__(self):
        return len(self.__objs)

    def __str__(self):
        if self.__external:
            print "External Path: ["
        else:
            print "Internal Path: ["
        for _obj in self.__objs:
            print str(_obj)
        print "]"

    def isExternal(self):
        """Test if the Path is an external border.

isExternal()
        """
        return self.__external

    def isCircular(self):
        """Test if the Path is a Circle or closed Arc.

isCircular()        
        """
    def getPath(self):
        """Return the objects defining the Path.

getPath()

This method returns a list of objects.
        """
        return self.__objs[:]

    def inPath(self, x, y):
        """Test if a coordinate pair are inside a Path.

inPath(x, y)

This method has two required arguments:

x: A float giving the "x" coordinate.
y: A float giving the "y" coordinate.

This method returns True if the Point is inside the
Path, and False otherwise.
        """
        _x = x
        if not isinstance(_x, float):
            _x = float(x)
        _y = y
        if not isinstance(_y, float):
            _y = float(y)
        _inside = False
        if self.__circular:
            assert len(self.__objs) == 1, "Invalid circular path length"
            _circ = self.__objs[0]
            _cx, _cy = _circ.getCenter().getCoords()
            _sep = math.hypot((_cx - _x), (_cy - _y))
            if _sep < _circ.getRadius():
                _inside = True
        else:
            _xp = 0.0
            _yp = 0.0
            _idx = None
            for _i in range(len(self.__objs)):
                _obj = self.__objs[_i]
                if isinstance(_obj, segment.Segment):
                    _p1, _p2 = _obj.getEndpoints()
                    _p1x, _p1y = _p1.getCoords()
                    _p2x, _p2y = _p2.getCoords()
                elif isinstance(_obj, arc.Arc):
                    _ep1, _ep2 = _obj.getEndpoints()
                    _p1x, _p1y = _ep1
                    _p2x, _p2y = _ep2
                elif isinstance(_obj, (segjoint.Chamfer, segjoint.Fillet)):
                    _p1, _p2 = _obj.getMovingPoints()
                    _p1x, _p1y = _p1.getCoords()
                    _p2x, _p2y = _p2.getCoords()
                _xdiff = _p2x - _p1x
                _ydiff = _p2y - _p1y
                _sqlen = pow(_xdiff, 2) + pow(_ydiff, 2)
                _r = ((_x - _p1x)*(_xdiff) + (_y - _p1y)*(_ydiff))/_sqlen
                if 0.0 < _r < 1.0:
                    _s = ((_p1y - _y)*(_xdiff) - (_p1x - _x)*(_ydiff))/_sqlen
                    if abs(_s) > 1e-10:
                        _xp = _p1x + (_r * _xdiff)
                        _yp = _p1y + (_r * _ydiff)
                        _idx = _i
                        break
            if _idx is not None:
                _count = 1
                for _i in range(len(self.__objs)):
                    if _i == _idx:
                        continue
                    _obj = self.__objs[_i]
                    if isinstance(_obj, segment.Segment):
                        _p1, _p2 = _obj.getEndpoints()
                        _p1x, _p1y = _p1.getCoords()
                        _p2x, _p2y = _p2.getCoords()
                    elif isinstance(_obj, arc.Arc):
                        _ep1, _ep2 = _obj.getEndpoints()
                        _p1x, _p1y = _ep1
                        _p2x, _p2y = _ep2
                    elif isinstance(_obj, (segjoint.Chamfer, segjoint.Fillet)):
                        _p1, _p2 = _obj.getMovingPoints()
                        _p1x, _p1y = _p1.getCoords()
                        _p2x, _p2y = _p2.getCoords()
                    _d = ((_p2x - _p1x)*(_yp - _y)) - ((_p2y - _p1y)*(_xp - _x))
                    if abs(_d) > 1e-10:
                        _n = ((_p1y - _y)*(_xp - _x)) - ((_p1x - _x)*(_yp - _y))
                        _r = _n/_d
                        if 0.0 < _r < 1.0:
                            _count = _count + 1
                if _count % 2: # need to test if point is in an arc ...
                    _inside = True
        return _inside
    
class HatchRegion(object):
    """The class defining a hatched area.

A HatchRegion object consists of one Path object defining
the external boundary of the hatching, and a list of zero
or more Paths defining any areas inside the enclosing Path
that are not hatched.
    """
    def __init__(self, extpath, voids=[]):
        """Initialize a HatchRegion.

h = HatchRegion(extpath[, voids])

The required argument "extpath" is a Path object defining
the external boundary of the hatching. The optional argument
"voids" is a list of Path objects defining areas within the
external Path that are not to be hatched.

A HatchRegion has the following methods:

        """
        if not isinstance(extpath, Path):
            raise TypeError, "Invalid external path: " + `extpath`
        if not extpath.isExternal():
            raise ValueError, "Path not defined to be an external path: " + `extpath`
        if not isinstance(voids, list):
            raise TypeError, "Invalid void list: " + `voids`
        for _void in voids:
            if not isinstance(_void, Path):
                raise TypeError, "Invalid path in void list: " + `_void`
            if _void.isExternal():
                raise ValueError, "Void area defined as external: " + `_void`
        self.__ext_path = extpath
        self.__voids = voids[:]

    def getExternalPath(self):
        """Return the external Path for the HatchRegion.

getExternalPath()        
        """
        return self.__ext_path

    def hasVoids(self):
        """Test if the HatchRegion has any internal non-hatched areas.

hasVoids()        
        """
        return len(self.__voids) > 0

    def getVoids(self):
        """Get any internal areas in the HatchRegion.

getVoids()        
        """
        return self.__voids[:]

def _seg_seg_touch(sega, segb):
    _touch = False
    _pa1, _pa2 = sega.getEndpoints()
    _pb1, _pb2 = segb.getEndpoints()
    if _pa1 is _pb1 or _pa1 is _pb2 or _pa2 is _pb1 or _pa2 is _pb2:
        _touch = True
    return _touch

def _seg_arc_touch(seg, a):
    _touch = False
    _p1, _p2 = seg.getEndpoints()
    _ep1, _ep2 = a.getEndpoints()
    if _p1 == _ep1 or _p1 == _ep2 or _p2 == _ep1 or _p2 == _ep2:
        _touch = True
    return _touch

def _arc_arc_touch(arca, arcb):
    _touch = False
    _aep1, _aep2 = arca.getEndpoints()
    _bep1, _bep2 = arcb.getEndpoints()
    if _aep1 == _bep1 or _aep1 == _bep2 or _aep2 == _bep1 or _aep2 == _bep2:
        _touch = True
    return _touch

def _seg_joint_touch(seg, joint):
    _touch = False
    _s1, _s2 = joint.getSegments()
    if _s1 is seg or _s2 is seg:
        _touch = True
    return _touch
    
def _old_validate_path(objlist):
    """Test if the objects in the objlist make a closed path.

_validate_path(objlist)

This function is private the the hatching code.    
    """
    if not isinstance(objlist, list):
        raise TypeError, "Invalid object list: " + `objlist`
    _startpt = None
    _nextpt = None
    _valid = False
    for _obj in objlist:
        print "testing object: " + `_obj`
        print "start: " + `_startpt`
        print "next: " + `_nextpt`
        if isinstance(_obj, segment.Segment):
            _p1, _p2 = _obj.getEndpoints()
            if _startpt is None:
                _startpt = _p1
                _nextpt = _p2
            else:
                if _nextpt == _p1:
                    _nextpt = _p2
                elif _nextpt == _p2:
                    _nextpt = _p1
                else:
                    break
        elif isinstance(_obj, arc.Arc):
            _ep1, _ep2 = _obj.getEndpoints()
            if _startpt is None:
                _startpt = _ep1
                _nextpt = _ep2
            else:
                if _nextpt == _ep1:
                    _nextpt = _ep2
                elif _startpt == _ep2:
                    _nextpt = _ep1
                else:
                    break
        elif isinstance(_obj, (segjoint.Chamfer, segjoint.Fillet)):
            _p1, _p2 = _obj.getMovingPoints()
            if _startpt is None:
                _startpt = _p1
                _nextpt = _p2
            else:
                if _nextpt == _p1:
                    _nextpt = _p2
                elif _nextpt == _p2:
                    _nextpt = _p1
                else:
                    break
        else:
            raise TypeError, "Invalid object in path: " + `_obj`
    if _startpt == _nextpt:
        _valid = True
    return _valid

def _can_touch(obja, objb):
    _touch = False
    if isinstance(obja, segment.Segment):
        if isinstance(objb, segment.Segment):
            _touch = _seg_seg_touch(obja, objb)
        elif isinstance(objb, arc.Arc):
            _touch = _seg_arc_touch(obja, objb)
        elif isinstance(objb, segjoint.SegJoint):
            _touch = _seg_joint_touch(obja, objb)
    elif isinstance(obja, arc.Arc):
        if isinstance(objb, segment.Segment):
            _touch = _seg_arc_touch(objb, obja)
        elif isinstance(objb, arc.Arc):
            _touch = _arc_arc_touch(obja, objb)
    elif isinstance(obja, segjoint.SegJoint):
        if isinstance(objb, segment.Segment):
            _touch = _seg_joint_touch(objb, obja)
    return _touch

def _validate_path(lyr, objlist):
    """Test if the objects in the objlist make a closed path.

_validate_path(objlist)

This function is private the the hatching code.    
    """
    if not isinstance(objlist, list):
        raise TypeError, "Invalid object list: " + `objlist`
    for _obj in objlist:
        _lobj = lyr.findObject(_obj)
        if _lobj is not _obj:
            raise ValueError, "Object not in layer: " + `_obj`
    _valid = True
    for _i in range(len(objlist) - 1):
        _obja = objlist[_i]
        _objb = objlist[_i+1]
        if not _can_touch(_obja, _objb):
            _valid = False
            break
    if _valid:
        _valid = _can_touch(objlist[0], objlist[-1])
    return _valid

def point_boundaries(plist):
    _xmin = None
    _xmax = None
    _ymin = None
    _ymax = None
    _set = False
    if len(plist) > 1:
        for _pt in plist:
            _x, _y = _pt.getCoords()
            if not _set:
                _xmin = _x
                _xmax = _x
                _ymin = _y
                _ymax = _y
            else:
                if _x < _xmin:
                    _xmin = _x
                if _x > _xmax:
                    _xmax = _x
                if _y < _ymin:
                    _ymin = _y
                if _y > _ymax:
                    _ymax = _y
    return (_xmin, _ymin, _xmax, _ymax)

def point_in_path(path):
    hits = 0
    for seg in path:
        p1, p2 = seg.getEndpoints()
        p1x, p1y = p1.getEndpoints()
        p2x, p2y = p2.getEndpoints()
        xmin = min(p1x, p2x)
        xmax = max(p1x, p2x)
        ymin = min(p1y, p2y)
        ymax = max(p1y, p2y)
        if hx < xmin or hx > max or hy > ymax:
            continue
        hits = 1 - hits
    return hits
        
def draw_path(path):
    if len(path):
        print "path: ["
        for seg in path:
            print seg
        print "]"

def make_paths(pt, seg, sdict):
    paths = []
    print "initial segment: " + str(seg)
    sp1, sp2 = seg.getEndpoints()
    if pt is sp1:
        sp = sp1
    else:
        sp = sp2
    print "start point: " + str(sp)
    segkeys = {}
    path = []
    segkeys[seg] = pt
    path.append(seg)
    draw_path(path)
    paths.append(path)
    while(len(paths)):
        path = paths.pop()
        draw_path(path)
        seg = path[-1]
        print "path final segment: " + str(seg)
        # print "segkey: " + str(segkeys[seg])
        p1, p2 = seg.getEndpoints()
        print "p1: " + str(p1)
        if p1 in sdict and segkeys[seg] is not p1:
            if p1 is sp:
                print "complete path:"
                draw_path(path)
            else:
                for p1seg in sdict[p1]:
                    if p1seg not in path:
                        segkeys[p1seg] = p1
                        path.append(p1seg)
                        # print "new path:"
                        draw_path(path)
                        paths.append(path)
        print "p2: " + str(p2)
        if p2 in sdict and segkeys[seg] is not p2:
            if p2 is sp:
                print "complete path:"
                draw_path(path)
            else:
                for p2seg in sdict[p2]:
                    if p2seg not in path:
                        segkeys[p2seg] = p2
                        path.append(p2seg)
                        # print "new_path:"
                        draw_path(path)
                        paths.append(path)


def check_clist(ct, clist):
    xct, yct = ct.getCenter().getCoords()
    rct = ct.getRadius()
    add_flag = True
    i = 0
    while (i < len(clist)):
        _c = clist[i]
        x, y = _c.getCenter().getCoords()
        r = _c.getRadius()
        sep = math.hypot((xct - x), (yct - y))
        if sep < r: # ct center point inside _c
            if sep + rct < r:
                add_flag = False
            else:
                i = i + 1
        elif sep < rct: # _c center point inside ct
            if sep + r < rct:
                del clist[i]
            else:
                i = i + 1
        else: # two circle that may or may not overlap
            i = i + 1
        if not add_flag:
            break
    return add_flag
            
def get_contained_circles(l, c):
    clist = []
    xc, yc = c.getCenter().getCoords()
    rc = c.getRadius()
    for _cir in l.getLayerEntities("circle"):
        if _cir is c:
            continue
        x, y = _cir.getCenter().getCoords()
        r = _cir.getCoords()
        sep = math.hypot((xc - x), (yc - y))
        if sep + r < rc:
            if(check_clist(_cir, clist)):
                clist.append(_cir)
    return clist

def make_hatch_area(lyr, x, y):
    _x = x
    if not isinstance(_x, float):
        _x = float(x)
    _y = y
    if not isinstance(_y, float):
        _y = float(y)
    if not isinstance(lyr, layer.Layer):
        raise TypeError, "Invalid layer: " + `lyr`
    #
    # see if we're in a circle
    #
    _circle = None
    for _c in lyr.getLayerEntities("circle"):
        _xc, _yc = _c.getCenter().getCoords()
        _r = _c.getRadius()
        _sep = math.hypot((_xc - _x), (_yc - _y))
        if _sep < _r:
            if _circle is None:
                _circle = _c
            else:
                _rc = _circle.getRadius()
                if _r < _rc:
                    _circle = _c
    #
    # get the eligible points in the layer and
    # store any circles that may be fully inside
    # the bounding circle
    #
    _pts = {}
    _circle_voids = []
    if _circle is not None:
        _cx, _cy = _circle.getCenter().getCoords()
        _rad = _circle.getRadius()
        _xmin = _cx - _rad
        _ymin = _cy - _rad
        _xmax = _cx + _rad
        _ymax = _cy + _rad
        for _pt in lyr.getLayerEntities("point"):
            _x, _y = _pt.getCoords()
            if _x < _xmin or _y < _ymin or _y > _ymax:
                continue
            if _x > _xmax:
                break
            _sep = math.hypot((_cx - _x), (_cy - _y))
            if _sep < _rad:
                _addpt = True
                if lyr.countUsers(_pt) == 1:
                    _obj = lyr.usesObject(_pt)
                    if not isinstance(_obj, circle.Circle):
                        _addpt = False
                if _addpt:
                    _pts[_pt] = True
        for _circ in lyr.getLayerEntities("circle"):
            if _circ is _circle:
                continue
            _tcx, _tcy = _circ.getCenter().getCoords()
            _tr = _circ.getRadius()
            if (_tcx + _tr) > _xmax:
                break
            if ((_tcx - _tr) < _xmin or
                (_tcy - _tr) < _ymin or
                (_tcy + _tr) > _ymax):
                continue
            _sepmax = math.hypot((_cx - _tcx), (_cy - _tcy)) + _tr
            if _sepmax < _rad:
                _circle_voids.append(_circ)
    else:
        for _pt in lyr.getLayerEntities("point"):
            _addpt = True
            if lyr.countUsers(_pt) == 1:
                _obj = lyr.usesObject(_pt)
                if not isinstance(_obj, circle.Circle):
                    _addpt = False
            if _addpt:
                _pts[_pt] = True
    #
    # find the entites that can make closed paths
    #
    _objs = {}
    for _pt in _pts:
        for _user in lyr.usesObject(_pt):
            if isinstance(_user, (segment.Segment, arc.Arc,
                                  segjoint.Chamfer, segjoint.Fillet)):
                _objs[_user] = True
                if isinstance(_user, segment.Segment):
                    for _seguser in lyr.usesObject(_user):
                        _objs[_seguser] = True
    _paths = {}
    for _obj in _objs:
        _p1 = None
        _p2 = None
        if isinstance(_obj, segment.Segment):
            if _obj not in _paths:
                _paths[_obj] = []
            for _user in lyr.usesObject(_obj):
                if isinstance(_user, (segjoint.Chamfer, segjoint.Fillet)):
                    _paths[_obj].append(_user)
            _p1, _p2 = _obj.getEndpoints()
        elif isinstance(_obj, arc.Arc):
            _ep1, _ep2 = _obj.getEndpoints()
            for _pt in _pts:
                if _pt == _ep1:
                    _p1 = _pt
                elif _p2 == _ep2:
                    _p2 = _pt
                if _p1 is not None and _p2 is not None:
                    break
            if _p1 is None or _p2 is None:
                continue # only one arc endpoint in list
        else:
            _s1, _s2 = _obj.getSegments()
            if _obj not in _paths:
                _paths[_obj] = []
            _paths[_obj].append(_s1)
            _paths[_obj].append(_s2)
        if _p1 is not None:
            for _user in lyr.usesObject(_p1):
                if _user is not _obj:
                    if isinstance(_user, (segment.Segment, arc.Arc)):
                        _paths[_obj].append(_user)
        if _p2 is not None:
            for _user in lyr.usesObject(_p2):
                if _user is not _obj:
                    if isinstance(_user, (segment.Segment, arc.Arc)):
                        _paths[_obj].append(_user)
    #
    # remove any object that doesn't connect to another object
    #
    _objlist = _paths.keys()
    for _obj in _objlist:
        if len(_paths[_obj]) < 1:
            del _paths[_obj]
    #
    # try to make paths from the selected objects
    #
    _routes = {}
    _objlist = _paths.keys()
    _objcount = len(_objlist)
    for _obj in _objlist:
        _objpaths = []
        _path = [_obj]
        for _fullpath in _make_paths(_paths, _objcount, _obj, _path):
            print "path: " + str(_fullpath)
            _valid = _validate_path(lyr, _fullpath)
            if _valid:
                _objpaths.append(_fullpath)
            else:
                print "invalid path"
        _routes[_obj] = _objpaths

def _make_paths(pathdict, maxlen, tail, path):
    _paths = []
    _pathlen = len(path)
    _head = None
    if _pathlen <= maxlen and tail in pathdict:
        if _pathlen:
            _head = path[0]
        for _next in pathdict[tail]:
            if _next is _head:
                _good = True
                if _pathlen == 2:
                    if (isinstance(path[0], segment.Segment) and
                        isinstance(path[1], segment.Segment)):
                        _good = False
                if _good:
                    _paths.append(path)
            elif _next not in path:
                _path = path + [_next]
                for _newpath in _make_paths(pathdict, maxlen, _next, _path):
                    _paths.append(_newpath)
            else:
                pass
    return _paths

hpx = 3.0
hpy = 4.0

def hatchtests():
    p1 = point.Point(0,0)
    p2 = point.Point(10,0)
    p3 = point.Point(10,10)
    p4 = point.Point(0,10)
    s1 = segment.Segment(p1,p2)
    s2 = segment.Segment(p2,p3)
    s3 = segment.Segment(p3,p4)
    s4 = segment.Segment(p4,p1)
    l1 = layer.Layer('foo')
    l1.addObject(p1)
    l1.addObject(p2)
    l1.addObject(p3)
    l1.addObject(p4)
    l1.addObject(s1)
    l1.addObject(s2)
    l1.addObject(s3)
    l1.addObject(s4)
    # find_hatched_area(l1, hpx, hpy)
    p5 = point.Point(2.95, 3.95)
    l1.addObject(p5)
    c1 = circle.Circle(p5, 1)
    l1.addObject(c1)
    # find_hatched_area(l1, hpx, hpy)
    
if __name__ == '__main__':
    hatchtests()
