New function added: Generate Multi Lines on single figure.

TuningFork/draw.py

@@ -3,12 +3,12 @@
 import sys
 sys.path.append('..')
 import quickmap
+from quickmap import GetMultiMap, GetLine
 
-x,y = quickmap.DataFileToXYArray('without_damping.dat')
-quickmap.GetMap(x,y,smoothLine=True)
+x1,y1 = quickmap.DataFileToXYArray('without_damping.dat')
+x2,y2 = quickmap.DataFileToXYArray('with_damping.dat')
 
-x,y = quickmap.DataFileToXYArray('with_damping.dat')
-quickmap.GetMap(x,y,smoothLine=True)
+GetMultiMap(GetLine(x1, y1, smoothLine=True) + GetLine(x2, y2, smoothLine=True))
 
 sq_T = '14.633 19.327 24.256 29.192 34.589 39.547'.split(' ')
 sq_T = [float(e) for e in sq_T]

TuningFork/others_data/tmp1.dat

+# f(Hz) u
+
+260.048 0.059
+260.348 0.068
+260.648 0.081
+260.948 0.102
+261.248 0.136
+261.448 0.178
+261.648 0.260
+261.748 0.341
+261.798 0.403
+261.848 0.491
+261.898 0.629
+261.928 0.744
+261.948 0.863
+261.958 0.920
+261.968 0.999
+261.978 1.060
+261.988 1.154
+261.998 1.226
+262.008 1.321
+262.018 1.404
+262.028 1.452
+262.038 1.492
+262.048 1.500
+262.058 1.482
+262.068 1.434
+262.078 1.382
+262.088 1.306
+262.098 1.244
+262.118 1.103
+262.128 1.027
+262.228 0.570
+262.328 0.376
+262.428 0.277
+262.738 0.187
+263.548 0.075
+263.798 0.059
+264.048 0.043
+
+

TuningFork/others_data/tmp2.dat

+259.774 0.057
+260.074 0.065
+260.374 0.078
+260.674 0.097
+260.974 0.130
+261.274 0.201
+261.474 0.323
+261.574 0.464
+261.625 0.589
+261.675 0.793
+261.705 0.961
+261.715 1.034
+261.725 1.112
+261.735 1.167
+261.744 1.218
+261.754 1.267
+261.764 1.298
+261.774 1.305
+261.784 1.290
+261.794 1.268
+261.804 1.220
+261.814 1.179
+262.114 0.293
+262.314 0.182
+262.514 0.129
+262.814 0.089
+263.214 0.061
+263.414 0.052
+263.714 0.042
+263.774 0.041

deprecated.py

+import functools
+import inspect
+import warnings
+
+string_types = (type(b''), type(u''))
+
+
+def deprecated(reason):
+    """
+    This is a decorator which can be used to mark functions
+    as deprecated. It will result in a warning being emitted
+    when the function is used.
+    """
+
+    if isinstance(reason, string_types):
+
+        # The @deprecated is used with a 'reason'.
+        #
+        # .. code-block:: python
+        #
+        #    @deprecated("please, use another function")
+        #    def old_function(x, y):
+        #      pass
+
+        def decorator(func1):
+
+            if inspect.isclass(func1):
+                fmt1 = "Call to deprecated class {name} ({reason})."
+            else:
+                fmt1 = "Call to deprecated function {name} ({reason})."
+
+            @functools.wraps(func1)
+            def new_func1(*args, **kwargs):
+                warnings.simplefilter('always', DeprecationWarning)
+                warnings.warn(
+                    fmt1.format(name=func1.__name__, reason=reason),
+                    category=DeprecationWarning,
+                    stacklevel=2
+                )
+                warnings.simplefilter('default', DeprecationWarning)
+                return func1(*args, **kwargs)
+
+            return new_func1
+
+        return decorator
+
+    elif inspect.isclass(reason) or inspect.isfunction(reason):
+
+        # The @deprecated is used without any 'reason'.
+        #
+        # .. code-block:: python
+        #
+        #    @deprecated
+        #    def old_function(x, y):
+        #      pass
+
+        func2 = reason
+
+        if inspect.isclass(func2):
+            fmt2 = "Call to deprecated class {name}."
+        else:
+            fmt2 = "Call to deprecated function {name}."
+
+        @functools.wraps(func2)
+        def new_func2(*args, **kwargs):
+            warnings.simplefilter('always', DeprecationWarning)
+            warnings.warn(
+                fmt2.format(name=func2.__name__),
+                category=DeprecationWarning,
+                stacklevel=2
+            )
+            warnings.simplefilter('default', DeprecationWarning)
+            return func2(*args, **kwargs)
+
+        return new_func2
+
+    else:
+        raise TypeError(repr(type(reason)))
\ No newline at end of file

quickmap.py

@@ -9,6 +9,8 @@ import matplotlib.pyplot as plt
 from matplotlib import rcParams
 from scipy.interpolate import spline
 
+from deprecated import deprecated
+
 def dotMultiply(vctA, vctB):
     if len(vctA) != len(vctB):
         print("Error: While vcta is ", vctA, " and vctb is ", vctB)
@@ -18,16 +20,54 @@ def dotMultiply(vctA, vctB):
         ans += a * b
     return ans
 
-def GetMap(arrX, arrY, windowSizeX=12, windowSizeY=8, extendXRate=1, extendYRate=1, polyLine=False, poly_passO=False, poly_maxXPower=1, poly_inverseK=False, smoothLine=False):
+def __fetchAnonymousLineName():
+    for i in range(10000):
+        yield 'Unnamed Line ' + str(i)
+_fetchAnonymousLineName = __fetchAnonymousLineName()
+fetchAnonymousLineName = lambda :next(_fetchAnonymousLineName)
+
+@deprecated("Use GetMultiMap(GetLine(...)) rather than GetMap() please!")
+def GetMap(arrX, arrY, extendXRate=1, extendYRate=1, polyLine=False, poly_passO=False, poly_maxXPower=1, poly_inverseK=False, smoothLine=False):
+    '''
+    A wrapper to GetMultiMap(GetLine(args ...)), just check doc in GetLine().
+    '''
+    GetMultiMap(GetLine(arrX, arrY, fetchAnonymousLineName(), extendXRate, extendYRate, polyLine, poly_passO, poly_maxXPower, poly_inverseK, smoothLine))
+
+def GetMultiMap(lines, windowSizeX=12, windowSizeY=8):
+    '''
+    Usage: GetMultiMap(GetLine([1,2,3], [1,4,9]) + GetLine([2,2.1,2.2], [6,7,8]) + ...)
+    '''
+    colors = ['red', 'orange', 'blue', 'green', 'yellow', 'magenta', 'cyan', 'black'] # You can add more color like: '#123456', '#FFFFAE', etc
+    def __fetchColor():
+        for color in colors:
+            yield color
+        raise RuntimeError('Pre-defined colors are used out...... Check quickmap.py::GetMultiMap line 29 to add more color.')
+    _fetchColor = __fetchColor()
+    fetchColor = lambda :next(_fetchColor)
+    
+    plt.figure(figsize=(windowSizeX, windowSizeY))
+    for line in lines:
+        name, X, Y, px, py = line
+        plt.scatter(X, Y, color=fetchColor(), label="Sample Point ({})".format(name), linewidth=3)
+        if len(px) != len(py):
+            raise ValueError('Invalid line passed to GetMultiMap. Assertion len(px) == len(py) failed because {} != {}.'.format(len(px), len(py)))
+        if len(px) != 0:
+            plt.plot(px, py, color=fetchColor(), label="Fitting Line ({})".format(name), linewidth=2)
+    plt.grid()
+    plt.show()
+
+
+def GetLine(arrX, arrY, name=fetchAnonymousLineName(), extendXRate=1, extendYRate=1, polyLine=False, poly_passO=False, poly_maxXPower=1, poly_inverseK=False, smoothLine=False):
     '''
     Arguments:
-    arrX and arrY: array of coordinates of points. Ex: GetMap([1,2,3,4,5], [1,2,3,4,5]) -> y=x
+    arrX and arrY: array of coordinates of points. Ex: GetLine([1,2,3,4,5], [1,2,3,4,5]) -> y=x
+    name: Shown in GetMultiMap().
     polyLine(conflict with polyLine): Should I draw a fitting line by polynomial fitting?
-    smoothLine(conflict with smoothLine): Should I draw a fitting line by connecting all points and smooth them?
+    smoothLine(conflict with smoothLine, **RECOMMENDED**): Should I draw a fitting line by connecting all points and smooth them?
     passO: Should the fitting line pass (0,0)? That's saying, should k0 be zero?
-    maxXPower: If I should draw a fitting line, what polynomial function should I use? Ex: GetMap([1,2,3,4,5], [1,4,9,16,25], line=True, maxXPower) -> y=x^2
+    maxXPower: If I should draw a fitting line, what polynomial function should I use? Ex: GetLine([1,2,3,4,5], [1,4,9,16,25], line=True, maxXPower) -> y=x^2
     inverseK: Usually, I'm drawing the curl `y=KX`, while K=[k0,k1,k2,...], X=[x^0,x^1,x^2,...]. If this switch is set, I'll drawing the curl `KY=x`. Don't worry, this switch is transparent to you.
-    Ex: GetMap([0,1,1,4,4,9,9], [0,1,-1,2,-2,3,-3], poly_maxXPower=2, polyLine=True, poly_inverseK=True) -> y^2=x
+    Ex: GetLine([0,1,1,4,4,9,9], [0,1,-1,2,-2,3,-3], poly_maxXPower=2, polyLine=True, poly_inverseK=True) -> y^2=x
     
     ReturnValue:
     void
@@ -40,7 +80,7 @@ def GetMap(arrX, arrY, windowSizeX=12, windowSizeY=8, extendXRate=1, extendYRate
     maxX, maxY = max(arrX) * extendXRate, max(arrY) * extendYRate
     minX, minY = min(arrX) * extendXRate, min(arrY) * extendYRate
     X, Y = numpy.array(arrX), numpy.array(arrY)
-    print('Your input: ', arrX, '|', arrY)
+    print('Your input for {}: {} | {}'.format(name, arrX, arrY))
     if polyLine:
         print('You want a polynomial fitting, with maxXPower = {}, passO = {}, inverseK = {}.'.format(poly_maxXPower, poly_passO, poly_inverseK))
     if smoothLine:
@@ -58,20 +98,16 @@ def GetMap(arrX, arrY, windowSizeX=12, windowSizeY=8, extendXRate=1, extendYRate
 
     # Fire!
     if polyLine:
+        # Generate target line.
         kInit = [1 for _ in range(poly_maxXPower + 1)]
         kInit[0] = 0 # guarantee passO.
         if poly_inverseK:
             kFinal, _ = leastsq(lossFunc, kInit, args=(Y, X))
-            print('Fitting line done. k^-1=', kFinal)
+            print('Fitting polyLine done. k^-1=', kFinal)
         else:
             kFinal, _ = leastsq(lossFunc, kInit, args=(X, Y))
-            print('Fitting line done. k=', kFinal)
-    else:
-        print('Drawing map without fitting a line...\n')
+            print('Fitting polyLine done. k=', kFinal)
 
-    # Draw function map.
-    plt.figure(figsize=(windowSizeX, windowSizeY))
-    plt.scatter(X, Y, color="red", label="Sample Point", linewidth=3)
     if polyLine:
         if poly_inverseK:
             py = numpy.linspace(minY, maxY, 1000)
@@ -79,20 +115,12 @@ def GetMap(arrX, arrY, windowSizeX=12, windowSizeY=8, extendXRate=1, extendYRate
         else:
             px = numpy.linspace(minX, maxX, 1000)
             py = dotMultiply(kFinal, [px ** power for power in range(poly_maxXPower + 1)])
-        plt.plot(px, py, color="orange", label="Fitting Line", linewidth=2)
-    if smoothLine:
+    elif smoothLine:
         px = numpy.linspace(minX, maxX, 1000)
         py = spline(X, Y, px)
-        plt.plot(px, py, color="orange", label="Fitting Line", linewidth=2)
-    plt.legend()
-    plt.grid()
-    plt.show()
-
-    def toFloat(sstr):
-        if sstr == '':
-            return 0.0
-        else:
-            return float(sstr)
+    else:
+        px, py = [], []
+    return [(name, X, Y, px, py)] #Python list is addible.
 
 def _str_remove_extra_space(s):
     begin, end = 0, len(s)