from numpy import linspace, sin, cos, pi, array, asarray, ndarray, sqrt, abs
import pprint

from MatplotlibDraw import MatplotlibDraw
drawing_tool = MatplotlibDraw()

def point(x, y):
    return array((x, y), dtype=float)


class Shape:
    """
    Superclass for drawing different geometric shapes.
    Subclasses define shapes, but drawing, rotation, translation,
    etc. are done in generic functions in this superclass.
    """
    def __init__(self):
        """
        Until new version of shapes.py is ready:
        Never to be called from subclasses.
        """
        raise NotImplementedError(
            'class %s must implement __init__,\nwhich defines '
            'self.shapes as a list of Shape objects\n'
            '(and preferably self._repr string).\n'
            'Do not call Shape.__init__!' % \
            self.__class__.__name__)

    def __iter__(self):
        # We iterate over self.shapes many places, and will
        # get here if self.shapes is just a Shape object and
        # not the assumed list.
        print 'Warning: class %s does not define self.shapes\n'\
              'as a *list* of Shape objects'
        return [self]  # Make the iteration work

    def for_all_shapes(self, func, *args, **kwargs):
        if not hasattr(self, 'shapes'):
            # When self.shapes is lacking, we either come to
            # a special implementation of func or we come here
            # because Shape.func is just inherited. This is
            # an error if the class is not Curve or Point
            if isinstance(self, (Curve, Point)):
                return  # ok: no shapes and no func
            else:
                raise AttributeError('class %s has no shapes attribute!' %
                                     self.__class__.__name__)

        is_dict = True if isinstance(self.shapes, dict) else False
        for shape in self.shapes:
            if is_dict:
                shape = self.shapes[shape]
            getattr(shape, func)(*args, **kwargs)

    def draw(self):
        self.for_all_shapes('draw')

    def rotate(self, angle, center=point(0,0)):
        self.for_all_shapes('rotate', angle, center)

    def translate(self, vec):
        self.for_all_shapes('translate', vec)

    def scale(self, factor):
        self.for_all_shapes('scale', factor)

    def set_linestyle(self, style):
        self.for_all_shapes('set_linestyle', style)

    def set_linewidth(self, width):
        self.for_all_shapes('set_linewidth', width)

    def set_linecolor(self, color):
        self.for_all_shapes('set_linecolor', color)

    def set_arrow(self, style):
        self.for_all_shapes('set_arrow', style)

    def set_name(self, name):
        self.for_all_shapes('set_name', name)

    def set_filled_curves(self, fillcolor='', fillhatch=''):
        self.for_all_shapes('set_filled_curves', fillcolor, fillhatch)

    def __str__(self):
        return self.__class__.__name__

    def __repr__(self):
        #print 'repr in class', self.__class__.__name__
        return pprint.pformat(self.shapes)


class Curve(Shape):
    """General curve as a sequence of (x,y) coordintes."""
    def __init__(self, x, y):
        """
        `x`, `y`: arrays holding the coordinates of the curve.
        """
        self.x, self.y = x, y
        # Turn to numpy arrays
        self.x = asarray(self.x, dtype=float)
        self.y = asarray(self.y, dtype=float)
        #self.shapes must not be defined in this class
        #as self.shapes holds children objects:
        #Curve has no children (end leaf of self.shapes tree)

        self.linestyle = None
        self.linewidth = None
        self.linecolor = None
        self.fillcolor = None
        self.fillhatch = None
        self.arrow = None
        self.name = None

    def inside_plot_area(self, verbose=True):
        """Check that all coordinates are within drawing_tool's area."""
        xmin, xmax = self.x.min(), self.x.max()
        ymin, ymax = self.y.min(), self.y.max()
        t = drawing_tool
        inside = True
        if xmin < t.xmin:
            inside = False
            if verbose:
                print 'x_min=%g < plot area x_min=%g' % (xmin, t.xmin)
        if xmax > t.xmax:
            inside = False
            if verbose:
                print 'x_max=%g > plot area x_max=%g' % (xmax, t.xmax)
        if ymin < t.ymin:
            inside = False
            if verbose:
                print 'y_min=%g < plot area y_min=%g' % (ymin, t.ymin)
        if xmax > t.xmax:
            inside = False
            if verbose:
                print 'y_max=%g > plot area y_max=%g' % (ymax, t.ymax)
        return inside

    def draw(self):
        self.inside_plot_area()
        drawing_tool.define_curve(
            self.x, self.y,
            self.linestyle, self.linewidth, self.linecolor,
            self.arrow, self.fillcolor, self.fillhatch)

    def rotate(self, angle, center=point(0,0)):
        """
        Rotate all coordinates: `angle` is measured in degrees and
        (`x`,`y`) is the "origin" of the rotation.
        """
        angle = angle*pi/180
        x, y = center
        c = cos(angle);  s = sin(angle)
        xnew = x + (self.x - x)*c - (self.y - y)*s
        ynew = y + (self.x - x)*s + (self.y - y)*c
        self.x = xnew
        self.y = ynew

    def scale(self, factor):
        """Scale all coordinates by `factor`: ``x = factor*x``, etc."""
        self.x = factor*self.x
        self.y = factor*self.y

    def translate(self, vec):
        """Translate all coordinates by a vector `vec`."""
        self.x += vec[0]
        self.y += vec[1]

    def set_linecolor(self, color):
        self.linecolor = color

    def set_linewidth(self, width):
        self.linewidth = width

    def set_linestyle(self, style):
        self.linestyle = style

    def set_arrow(self, style=None):
        styles = ('->', '<-', '<->')
        if not style in styles:
            raise ValueError('style=%s must be in %s' % (style, styles))
        self.arrow = style

    def set_name(self, name):
        self.name = name

    def set_filled_curves(self, fillcolor='', fillhatch=''):
        self.fillcolor = fillcolor
        self.fillhatch = fillhatch

    def __str__(self):
        s = '%d (x,y) coordinates' % self.x.size
        if not self.inside_plot_area(verbose=False):
            s += ', some coordinates are outside plotting area!\n'
        props = ('linecolor', 'linewidth', 'linestyle', 'arrow', 'name',
                 'fillcolor', 'fillhatch')
        for prop in props:
            value = getattr(self, prop)
            if value is not None:
                s += ' %s: "%s"' % (prop, value)
        return s

    def __repr__(self):
        return str(self)


class Point(Shape):
    """A point (x,y) which can be rotated, translated, and scaled."""
    def __init__(self, x, y):
        self.x, self.y = x, y
        #self.shapes is not needed in this class

    def __add__(self, other):
        if isinstance(other, (list,tuple)):
            other = Point(other)
        return Point(self.x+other.x, self.y+other.y)

    # class Point is an abstract class - only subclasses are useful
    # and must implement draw
    def draw(self):
        raise NotImplementedError(
            'class %s must implement the draw method' %
            self.__class__.__name__)

    def rotate(self, angle, center=point(0,0)):
        """Rotate point an `angle` (in degrees) around (`x`,`y`)."""
        angle = angle*pi/180
        x, y = center
        c = cos(angle);  s = sin(angle)
        xnew = x + (self.x - x)*c - (self.y - y)*s
        ynew = y + (self.x - x)*s + (self.y - y)*c
        self.x = xnew
        self.y = ynew

    def scale(self, factor):
        """Scale point coordinates by `factor`: ``x = factor*x``, etc."""
        self.x = factor*self.x
        self.y = factor*self.y

    def translate(self, vec):
        """Translate point by a vector `vec`."""
        self.x += vec[0]
        self.y += vec[1]


# no need to store input data as they are invalid after rotations etc.
class Rectangle(Shape):
    def __init__(self, lower_left_corner, width, height):
        ll = lower_left_corner  # short form
        x = [ll[0], ll[0] + width,
             ll[0] + width, ll[0], ll[0]]
        y = [ll[1], ll[1], ll[1] + height,
             ll[1] + height, ll[1]]
        self.shapes = {'rectangle': Curve(x,y)}

class Triangle(Shape):
    """Triangle defined by its three vertices p1, p2, and p3."""
    def __init__(self, p1, p2, p3):
        x = [p1[0], p2[0], p3[0], p1[0]]
        y = [p1[1], p2[1], p3[1], p1[1]]
        self.shapes = {'triangle': Curve(x,y)}


class Line(Shape):
    def __init__(self, start, stop):
        x = [start[0], stop[0]]
        y = [start[1], stop[1]]
        self.shapes = {'line': Curve(x, y)}
        self.compute_formulas()

    def compute_formulas(self):
        x, y = self.shapes['line'].x, self.shapes['line'].y

        # Define equations for line:
        # y = a*x + b,  x = c*y + d
        try:
            self.a = (y[1] - y[0])/(x[1] - x[0])
            self.b = y[0] - self.a*x[0]
        except ZeroDivisionError:
            # Vertical line, y is not a function of x
            self.a = None
            self.b = None
        try:
            if self.a is None:
                self.c = 0
            else:
                self.c = 1/float(self.a)
            if self.b is None:
                self.d = x[1]
        except ZeroDivisionError:
            # Horizontal line, x is not a function of y
            self.c = None
            self.d = None

    def __call__(self, x=None, y=None):
        """Given x, return y on the line, or given y, return x."""
        self.compute_formulas()
        if x is not None and self.a is not None:
            return self.a*x + self.b
        elif y is not None and self.c is not None:
            return self.c*y + self.d
        else:
            raise ValueError(
                'Line.__call__(x=%s, y=%s) not meaningful' % \
                (x, y))

# First implementation of class Circle
class Circle(Shape):
    def __init__(self, center, radius, resolution=180):
        self.center, self.radius = center, radius
        self.resolution = resolution

        t = linspace(0, 2*pi, resolution+1)
        x0 = center[0];  y0 = center[1]
        R = radius
        x = x0 + R*cos(t)
        y = y0 + R*sin(t)
        self.shapes = {'circle': Curve(x, y)}

    def __call__(self, theta):
        """Return (x, y) point corresponding to theta."""
        return self.center[0] + self.radius*cos(theta), \
               self.center[1] + self.radius*sin(theta)


class Arc(Shape):
    def __init__(self, center, radius,
                 start_degrees, opening_degrees,
                 resolution=180):
        self.center = center
        self.radius = radius
        self.start_degrees = start_degrees*pi/180  # radians
        self.opening_degrees = opening_degrees*pi/180
        self.resolution = resolution

        t = linspace(self.start_degrees,
                     self.start_degrees + self.opening_degrees,
                     resolution+1)
        x0 = center[0];  y0 = center[1]
        R = radius
        x = x0 + R*cos(t)
        y = y0 + R*sin(t)
        self.shapes = {'arc': Curve(x, y)}

    def __call__(self, theta):
        """Return (x,y) point at start_degrees + theta."""
        theta = theta*pi/180
        t = self.start_degrees + theta
        x0 = self.center[0]
        y0 = self.center[1]
        R = self.radius
        x = x0 + R*cos(t)
        y = y0 + R*sin(t)
        return (x, y)

# Alternative for small arcs: Parabola

class Parabola(Shape):
    def __init__(self, start, mid, stop, resolution=21):
        self.p1, self.p2, self.p3 = start, mid, stop

        # y as function of x? (no point on line x=const?)
        tol = 1E-14
        if abs(self.p1[0] - self.p2[0]) > 1E-14 and \
           abs(self.p2[0] - self.p3[0]) > 1E-14 and \
           abs(self.p3[0] - self.p1[0]) > 1E-14:
            self.y_of_x = True
        else:
            self.y_of_x = False
        # x as function of y? (no point on line y=const?)
        tol = 1E-14
        if abs(self.p1[1] - self.p2[1]) > 1E-14 and \
           abs(self.p2[1] - self.p3[1]) > 1E-14 and \
           abs(self.p3[1] - self.p1[1]) > 1E-14:
            self.x_of_y = True
        else:
            self.x_of_y = False

        if self.y_of_x:
            x = linspace(start[0], end[0], resolution)
            y = self(x=x)
        elif self.x_of_y:
            y = linspace(start[1], end[1], resolution)
            x = self(y=y)
        else:
            raise ValueError(
                'Parabola: two or more points lie on x=const '
                'or y=const - not allowed')
        self.shapes = {'parabola': Curve(x, y)}

    def __call__(self, x=None, y=None):
        if x is not None and self.y_of_x:
            return self._L2x(self.p1, self.p2)*self.p3[1] + \
                   self._L2x(self.p2, self.p3)*self.p1[1] + \
                   self._L2x(self.p3, self.p1)*self.p2[1]
        elif y is not None and self.x_of_y:
            return self._L2y(self.p1, self.p2)*self.p3[0] + \
                   self._L2y(self.p2, self.p3)*self.p1[0] + \
                   self._L2y(self.p3, self.p1)*self.p2[0]
        else:
            raise ValueError(
                'Parabola.__call__(x=%s, y=%s) not meaningful' % \
                (x, y))

    def _L2x(self, x, pi, pj, pk):
        return (x - pi[0])*(x - pj[0])/((pk[0] - pi[0])*(pk[0] - pj[0]))

    def _L2y(self, y, pi, pj, pk):
        return (y - pi[1])*(y - pj[1])/((pk[1] - pi[1])*(pk[1] - pj[1]))


class Circle(Arc):
    def __init__(self, center, radius, resolution=180):
        Arc.__init__(self, center, radius, 0, 360, resolution)

# class Wall: horizontal Line with many small Lines 45 degrees
class XWall(Shape):
    def __init__(start, length, dx, below=True):
        n = int(round(length/float(dx)))  # no of intervals
        x = linspace(start[0], start[0] + length, n+1)
        y = start[1]
        dy = dx
        if below:
            taps = [Line((xi,y-dy), (xi+dx, y)) for xi in x[:-1]]
        else:
            taps = [Line((xi,y), (xi+dx, y+dy)) for xi in x[:-1]]
        self.shapes = [Line(start, (start[0]+length, start[1]))] + taps

class Wall(Shape):
    def __init__(self, start, length, thickness, rotation_angle=0):
        p1 = asarray(start)
        p2 = p1 + asarray([length, 0])
        p3 = p2 + asarray([0, thickness])
        p4 = p1 + asarray([0, thickness])
        p5 = p1
        x = [p[0] for p in p1, p2, p3, p4, p5]
        y = [p[1] for p in p1, p2, p3, p4, p5]
        wall = Curve(x, y)
        wall.set_filled_curves('white', '/')
        wall.rotate(rotation_angle, start)
        self.shapes = {'wall': wall}

"""
    def draw(self):
        x = self.shapes['wall'].x
        y = self.shapes['wall'].y
        drawing_tool.ax.fill(x, y, 'w',
                             edgecolor=drawing_tool.linecolor,
                             hatch='/')
"""

class CurveWall(Shape):
    def __init__(self, x, y, thickness):
        x1 = asarray(x, float)
        y1 = asarray(y, float)
        x2 = x1
        y2 = y1 + thickness
        from numpy import concatenate
        # x1/y1 + reversed x2/y2
        x = concatenate((x1, x2[-1::-1]))
        y = concatenate((y1, y2[-1::-1]))
        wall = Curve(x, y)
        wall.set_filled_curves('white', '/')
        self.shapes = {'wall': wall}

"""
    def draw(self):
        x = self.shapes['wall'].x
        y = self.shapes['wall'].y
        drawing_tool.ax.fill(x, y, 'w',
                             edgecolor=drawing_tool.linecolor,
                             hatch='/')
"""


class Text(Point):
    def __init__(self, text, position, alignment='center', fontsize=18):
        self.text = text
        self.alignment, self.fontsize = alignment, fontsize
        is_sequence(position, length=2, can_be_None=True)
        Point.__init__(self, position[0], position[1])
        #no need for self.shapes here

    def draw(self):
        drawing_tool.text(self.text, (self.x, self.y),
                          self.alignment, self.fontsize)

    def __str__(self):
        return 'text "%s" at (%g,%g)' % (self.text, self.x, self.y)

    def __repr__(self):
        return str(self)


class Text_wArrow(Text):
    def __init__(self, text, position, arrow_tip,
                 alignment='center', fontsize=18):
        is_sequence(arrow_tip, length=2, can_be_None=True)
        self.arrow_tip = arrow_tip
        Text.__init__(self, text, position, alignment, fontsize)

    def draw(self):
        drawing_tool.text(self.text, self.position,
                          self.alignment, self.fontsize,
                          self.arrow_tip)
    def __str__(self):
        return 'annotation "%s" at (%g,%g) with arrow to (%g,%g)' % \
               (self.text, self.x, self.y,
                self.arrow_tip[0], self.arrow_tip[1])

    def __repr__(self):
        return str(self)


class Axis(Shape):
    def __init__(self, bottom_point, length, label, below=True,
                 rotation_angle=0, label_spacing=1./25):
        """
        Draw axis from bottom_point with `length` to the right
        (x axis). Place label below (True) or above (False) axis.
        Then return `rotation_angle` (in degrees).
        To make a standard x axis, call with ``below=True`` and
        ``rotation_angle=0``. To make a standard y axis, call with
        ``below=False`` and ``rotation_angle=90``.
        A tilted axis can also be drawn.
        The `label_spacing` denotes the space between the symbol
        and the arrow tip as a fraction of the length of the plot
        in x direction.
        """
        # Arrow is vertical arrow, make it horizontal
        arrow = Arrow(bottom_point, length, rotation_angle=-90)
        arrow.rotate(rotation_angle, bottom_point)
        spacing = drawing_tool.xrange*label_spacing
        if below:
            spacing = - spacing
        label_pos = [bottom_point[0] + length, bottom_point[1] + spacing]
        symbol = Text(label, position=label_pos)
        symbol.rotate(rotation_angle, bottom_point)
        self.shapes = {'arrow': arrow, 'symbol': symbol}

class Gravity(Axis):
    """Downward-pointing gravity arrow with the symbol g."""
    def __init__(self, start, length):
        Axis.__init__(self, start, length, '$g$', below=False,
                      rotation_angle=-90, label_spacing=1./30)

def test_Axis():
    set_coordinate_system(xmin=0, xmax=15, ymin=0, ymax=15, axis=True)
    x_axis = Axis((7.5,2), 5, 'x', rotation_angle=0)
    y_axis = Axis((7.5,2), 5, 'y', below=False, rotation_angle=90)
    system = Compose({'x axis': x_axis, 'y axis': y_axis})
    system.draw()
    drawing_tool.display()
    set_linestyle('dashed')
    system.shapes['x axis'].rotate(40, (7.5, 2))
    system.shapes['y axis'].rotate(40, (7.5, 2))
    system.draw()
    drawing_tool.display()
    print repr(system)


class DistanceSymbol(Shape):
    """
    Arrow with symbol at the midpoint,
    for identifying a distance with a symbol.
    """
    def __init__(self, start, end, symbol, fontsize=14):
        start = asarray(start, float)
        end = asarray(end, float)
        mid = 0.5*(start + end)  # midpoint of start-end line
        tangent = end - start
        normal = asarray([-tangent[1], tangent[0]])/\
                 sqrt(tangent[0]**2 + tangent[1]**2)
        symbol_pos = mid + normal*drawing_tool.xrange/60.
        self.shapes = {'arrow': Arrow1(start, end, style='<->'),
                       'symbol': Text(symbol, symbol_pos, fontsize=fontsize)}


class ArcSymbol(Shape):
    def __init__(self, symbol, center, radius,
                 start_degrees, opening_degrees,
                 resolution=180, fontsize=14):
        arc = Arc(center, radius, start_degrees, opening_degrees,
                  resolution)
        mid = asarray(arc(opening_degrees/2.))
        normal = mid - asarray(center, float)
        normal = normal/sqrt(normal[0]**2 + normal[1]**2)
        symbol_pos = mid + normal*drawing_tool.xrange/60.
        self.shapes = {'arc': arc,
                       'symbol': Text(symbol, symbol_pos, fontsize=fontsize)}

class Compose(Shape):
    def __init__(self, shapes):
        """shapes: list or dict of Shape objects."""
        self.shapes = shapes


# can make help methods: Line.midpoint, Line.normal(pt, dir='left') -> (x,y)

# list annotations in each class? contains extra annotations for explaining
# important parameters to the constructor, e.g., Line.annotations holds
# start and end as Text objects. Shape.demo calls shape.draw and
# for annotation in self.demo: annotation.draw() YES!
# Can make overall demo of classes by making objects and calling demo
# Could include demo fig in each constructor


class Arrow1(Shape):
    """Draw an arrow as Line with arrow."""
    def __init__(self, start, end, style='->'):
        self.start, self.end, self.style = start, end, style
        self.shapes = {'arrow': Line(start, end, arrow=style)}

class Arrow3(Shape):
    """Draw a vertical line and arrow head. Then rotate `rotation_angle`."""
    def __init__(self, bottom_point, length, rotation_angle=0):
        self.bottom = bottom_point
        self.length = length
        self.angle = rotation_angle

        top = (self.bottom[0], self.bottom[1] + self.length)
        main = Line(self.bottom, top)
        #head_length = self.length/8.0
        head_length = drawing_tool.xrange/50.
        head_degrees = 30*pi/180
        head_left_pt = (top[0] - head_length*sin(head_degrees),
                        top[1] - head_length*cos(head_degrees))
        head_right_pt = (top[0] + head_length*sin(head_degrees),
                         top[1] - head_length*cos(head_degrees))
        head_left = Line(head_left_pt, top)
        head_right = Line(head_right_pt, top)
        head_left.set_linestyle('solid')
        head_right.set_linestyle('solid')
        self.shapes = {'line': main, 'head left': head_left,
                       'head right': head_right}

        # rotate goes through self.shapes so this must be initialized first
        self.rotate(rotation_angle, bottom_point)

Arrow = Arrow3  # backward compatibility


class Wheel(Shape):
    def __init__(self, center, radius, inner_radius=None, nlines=10):
        self.center = center
        self.radius = radius
        if inner_radius is None:
            self.inner_radius = radius/5.0
        else:
            self.inner_radius = inner_radius
        self.nlines = nlines

        outer = Circle(self.center, self.radius)
        inner = Circle(self.center, self.inner_radius)
        lines = []
        # Draw nlines+1 since the first and last coincide
        # (then nlines lines will be visible)
        t = linspace(0, 2*pi, self.nlines+1)

        Ri = self.inner_radius;  Ro = self.radius
        x0 = self.center[0];  y0 = self.center[1]
        xinner = x0 + Ri*cos(t)
        yinner = y0 + Ri*sin(t)
        xouter = x0 + Ro*cos(t)
        youter = y0 + Ro*sin(t)
        lines = [Line((xi,yi),(xo,yo)) for xi, yi, xo, yo in \
                 zip(xinner, yinner, xouter, youter)]
        self.shapes = [outer, inner] + lines

class Wave(Shape):
    def __init__(self, xstart, xstop,
                 wavelength, amplitude, mean_level):
        self.xstart = xstart
        self.xstop = xstop
        self.wavelength = wavelength
        self.amplitude = amplitude
        self.mean_level = mean_level

        npoints = (self.xstop - self.xstart)/(self.wavelength/61.0)
        x = linspace(self.xstart, self.xstop, npoints)
        k = 2*pi/self.wavelength # frequency
        y = self.mean_level + self.amplitude*sin(k*x)
        self.shapes = {'waves': Curve(x,y)}



# make a version of Spring using Point class


class Spring(Shape):
    def __init__(self, bottom_point, length, tagwidth, ntags=4):
        """
        Specify a vertical spring, starting at bottom_point and
        having a specified lengths. In the middle third of the
        spring there are ntags tags.
        """
        self.B = bottom_point
        self.n = ntags - 1  # n counts tag intervals
        # n must be odd:
        if self.n % 2 == 0:
            self.n = self.n+1
        self.L = length
        self.w = tagwidth

        B, L, n, w = self.B, self.L, self.n, self.w  # short forms
        t = L/(3.0*n)  # must be better worked out
        P0 = (B[0], B[1]+L/3.0)
        P1 = (B[0], B[1]+L/3.0+t/2.0)
        P2 = (B[0], B[1]+L*2/3.0)
        P3 = (B[0], B[1]+L)
        line1 = Line(B, P1)
        lines = [line1]
        #line2 = Line(P2, P3)
        T1 = P1
        T2 = (T1[0] + w, T1[1] + t/2.0)
        lines.append(Line(T1,T2))
        T1 = (T2[0], T2[1])
        for i in range(n):
            T2 = (T1[0] + (-1)**(i+1)*2*w, T1[1] + t/2.0)
            lines.append(Line(T1, T2))
            T1 = (T2[0], T2[1])
        T2 = (T1[0] + w, T1[1] + t/2.0)
        lines.append(Line(T1,T2))

        #print P2, T2
        lines.append(Line(T2, P3))
        self.shapes = lines


# COMPOSITE types:
# MassSpringForce: Line(horizontal), Spring, Rectangle, Arrow/Line(w/arrow)
# must be easy to find the tip of the arrow
# Maybe extra dict: self.name['mass'] = Rectangle object - YES!

def _test1():
    set_coordinate_system(xmin=0, xmax=10, ymin=0, ymax=10)
    l1 = Line((0,0), (1,1))
    l1.draw()
    input(': ')
    c1 = Circle((5,2), 1)
    c2 = Circle((6,2), 1)
    w1 = Wheel((7,2), 1)
    c1.draw()
    c2.draw()
    w1.draw()
    hardcopy()
    display()  # show the plot

def _test2():
    set_coordinate_system(xmin=0, xmax=10, ymin=0, ymax=10)
    l1 = Line((0,0), (1,1))
    l1.draw()
    input(': ')
    c1 = Circle((5,2), 1)
    c2 = Circle((6,2), 1)
    w1 = Wheel((7,2), 1)
    filled_curves(True)
    set_linecolor('blue')
    c1.draw()
    set_linecolor('aqua')
    c2.draw()
    filled_curves(False)
    set_linecolor('red')
    w1.draw()
    hardcopy()
    display()  # show the plot

def _test3():
    """Test example from the book."""
    set_coordinate_system(xmin=0, xmax=10, ymin=0, ymax=10)
    l1 = Line(start=(0,0), stop=(1,1))  # define line
    l1.draw()        # make plot data
    r1 = Rectangle(lower_left_corner=(0,1), width=3, height=5)
    r1.draw()
    Circle(center=(5,7), radius=1).draw()
    Wheel(center=(6,2), radius=2, inner_radius=0.5, nlines=7).draw()
    hardcopy()
    display()

def _test4():
    """Second example from the book."""
    set_coordinate_system(xmin=0, xmax=10, ymin=0, ymax=10)
    r1 = Rectangle(lower_left_corner=(0,1), width=3, height=5)
    c1 = Circle(center=(5,7), radius=1)
    w1 = Wheel(center=(6,2), radius=2, inner_radius=0.5, nlines=7)
    c2 = Circle(center=(7,7), radius=1)
    filled_curves(True)
    c1.draw()
    set_linecolor('blue')
    r1.draw()
    set_linecolor('aqua')
    c2.draw()
    # Add thick aqua line around rectangle:
    filled_curves(False)
    set_linewidth(4)
    r1.draw()
    set_linecolor('red')
    # Draw wheel with thick lines:
    w1.draw()
    hardcopy('tmp_colors')
    display()


def _test5():
    set_coordinate_system(xmin=0, xmax=10, ymin=0, ymax=10)
    c = 6.  # center point of box
    w = 2.  # size of box
    L = 3
    r1 = Rectangle((c-w/2, c-w/2), w, w)
    l1 = Line((c,c-w/2), (c,c-w/2-L))
    linecolor('blue')
    filled_curves(True)
    r1.draw()
    linecolor('aqua')
    filled_curves(False)
    l1.draw()
    hardcopy()
    display()  # show the plot

def rolling_wheel(total_rotation_angle):
    """Animation of a rotating wheel."""
    set_coordinate_system(xmin=0, xmax=10, ymin=0, ymax=10)

    import time
    center = (6,2)
    radius = 2.0
    angle = 2.0
    pngfiles = []
    w1 = Wheel(center=center, radius=radius, inner_radius=0.5, nlines=7)
    for i in range(int(total_rotation_angle/angle)):
        w1.draw()
        print 'XXXXXXXXXXXXXXXXXXXXXX BIG PROBLEM WITH ANIMATE!!!'
        display()


        filename = 'tmp_%03d' % i
        pngfiles.append(filename + '.png')
        hardcopy(filename)
        time.sleep(0.3)  # pause

        L = radius*angle*pi/180  # translation = arc length
        w1.rotate(angle, center)
        w1.translate((-L, 0))
        center = (center[0] - L, center[1])

        erase()
    cmd = 'convert -delay 50 -loop 1000 %s tmp_movie.gif' \
          % (' '.join(pngfiles))
    print 'converting PNG files to animated GIF:\n', cmd
    import commands
    failure, output = commands.getstatusoutput(cmd)
    if failure:  print 'Could not run', cmd

def is_sequence(seq, length=None,
                can_be_None=False, error_message=True):
    if can_be_None:
        legal_types = (list,tuple,ndarray,None)
    else:
        legal_types = (list,tuple,ndarray)

    if isinstance(seq, legal_types):
        if length is not None:
            if length == len(seq):
                return True
            elif error_message:
                raise TypeError('%s is %s; must be %s of length %d' %
                            (str(point), type(point),
                            ', '.join([str(t) for t in legal_types]),
                             len(seq)))
            else:
                return False
        else:
            return True
    elif error_message:
        raise TypeError('%s is %s; must be %s' %
                        str(point), type(point),
                        ', '.join([str(t) for t in legal_types]))
    else:
        return False

if __name__ == '__main__':
    #rolling_wheel(40)
    #_test1()
    #_test3()
    funcs = [
        #test_Axis,
        test_inclined_plane,
        ]
    for func in funcs:
        func()
        raw_input('Type Return: ')