packages/charted/lib/core/interpolators/interpolators.dart - observatory_pub_packages - Git at Google

 //
 // Copyright 2014 Google Inc. All rights reserved.
 //
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file or at
 // https://developers.google.com/open-source/licenses/bsd
 //

 part of charted.core.interpolators;

 /// [Interpolator] accepts [t], such that 0.0 < t < 1.0 and returns
 /// a value in a pre-defined range.
 typedef Interpolator<S> = S Function(num t);

 /// [InterpolatorGenerator] accepts two parameters [a], [b] and returns an
 /// [Interpolator] for transitioning from [a] to [b]
 typedef InterpolatorGenerator<T, S> = Interpolator<S> Function(T a, T b);

 /// List of registered interpolators - [createInterpolatorFromRegistry]
 /// iterates through this list from backwards and the first non-null
 /// interpolate function is returned to the caller.
 List<InterpolatorGenerator> _interpolators = [createInterpolatorByType];

 /// Returns a default interpolator between values [a] and [b]. Unless
 /// more interpolators are added, one of the internal implementations are
 /// selected by the type of [a] and [b].
 Interpolator createInterpolatorFromRegistry(a, b) {
   Interpolator fn;
   int i = _interpolators.length;
   while (--i >= 0 && fn == null) {
     fn = _interpolators[i](a, b);
   }
   return fn;
 }

 /// Creates an interpolator based on the type of [a] and [b].
 ///
 /// Usage note: Use this method only when type of [a] and [b] are not known.
 ///     When used, this function will prevent tree shaking of all built-in
 ///     interpolators.
 Interpolator createInterpolatorByType(a, b) {
   if (a is List && b is List) {
     return createListInterpolator(a, b);
   } else if (a is Map && b is Map) {
     return createMapInterpolator(a, b);
   } else if (a is String && b is String) {
     return createStringInterpolator(a, b);
   } else if (a is num && b is num) {
     return createNumberInterpolator(a, b);
   } else if (a is Color && b is Color) {
     return createRgbColorInterpolator(a, b);
   } else {
     return (t) => (t <= 0.5) ? a : b;
   }
 }

 //
 // Implementations of InterpolatorGenerator
 //

 /// Generate a numeric interpolator between numbers [a] and [b]
 Interpolator<num> createNumberInterpolator(num a, num b) {
   b -= a;
   return (t) => a + b * t;
 }

 /// Generate a rounded number interpolator between numbers [a] and [b]
 Interpolator<num> createRoundedNumberInterpolator(num a, num b) {
   b -= a;
   return (t) => (a + b * t).round();
 }

 /// Generate an interpolator between two strings [a] and [b].
 ///
 /// The interpolator will interpolate all the number pairs in both strings
 /// that have same number of numeric parts.  The function assumes the non
 /// number part of the string to be identical and would use string [b] for
 /// merging the non numeric part of the strings.
 ///
 /// Eg: Interpolate between $100.0 and $150.0
 Interpolator<String> createStringInterpolator(String a, String b) {
   if (a == null || b == null) return (num t) => b;

   // See if both A and B represent colors as RGB or HEX strings.
   // If yes, use color interpolators
   if (Color.isRgbColorString(a) && Color.isRgbColorString(b)) {
     return createRgbColorInterpolator(
         new Color.fromRgbString(a), new Color.fromRgbString(b));
   }

   // See if both A and B represent colors as HSL strings.
   // If yes, use color interpolators.
   if (Color.isHslColorString(a) && Color.isHslColorString(b)) {
     return createHslColorInterpolator(
         new Color.fromHslString(a), new Color.fromHslString(b));
   }

   var numberRegEx = new RegExp(r'[-+]?(?:\d+\.?\d*|\.?\d+)(?:[eE][-+]?\d+)?');
   var numMatchesInA = numberRegEx.allMatches(a);
   var numMatchesInB = numberRegEx.allMatches(b);
   List<String> stringParts = [];
   List<String> numberPartsInA = [];
   List<String> numberPartsInB = [];
   List<Interpolator<num>> interpolators = [];
   int s0 = 0;

   numberPartsInA.addAll(numMatchesInA.map((m) => m.group(0)));

   for (Match m in numMatchesInB) {
     stringParts.add(b.substring(s0, m.start));
     numberPartsInB.add(m.group(0));
     s0 = m.end;
   }

   if (s0 < b.length) stringParts.add(b.substring(s0));

   int numberLength = math.min(numberPartsInA.length, numberPartsInB.length);
   int maxLength = math.max(numberPartsInA.length, numberPartsInB.length);
   for (var i = 0; i < numberLength; i++) {
     interpolators.add(createNumberInterpolator(
         num.parse(numberPartsInA[i]), num.parse(numberPartsInB[i])));
   }
   if (numberPartsInA.length < numberPartsInB.length) {
     for (var i = numberLength; i < maxLength; i++) {
       interpolators.add(createNumberInterpolator(
           num.parse(numberPartsInB[i]), num.parse(numberPartsInB[i])));
     }
   }

   return (num t) {
     StringBuffer sb = new StringBuffer();
     for (var i = 0; i < stringParts.length; i++) {
       sb.write(stringParts[i]);
       if (interpolators.length > i) {
         sb.write(interpolators[i](t));
       }
     }
     return sb.toString();
   };
 }

 /// Generate an interpolator for RGB values.
 Interpolator<String> createRgbColorInterpolator(Color a, Color b) {
   if (a == null || b == null) return (num t) => b.toRgbaString();
   var ar = a.r, ag = a.g, ab = a.b, br = b.r - ar, bg = b.g - ag, bb = b.b - ab;

   return (num t) => new Color.fromRgba((ar + br * t).round(),
           (ag + bg * t).round(), (ab + bb * t).round(), 1.0)
       .toRgbaString();
 }

 /// Generate an interpolator using HSL color system converted to Hex string.
 Interpolator<String> createHslColorInterpolator(Color a, Color b) {
   if (a == null || b == null) return (num t) => b.toHslaString();
   var ah = a.h, as = a.s, al = a.l, bh = b.h - ah, bs = b.s - as, bl = b.l - al;

   return (num t) => new Color.fromHsla((ah + bh * t).round(),
           (as + bs * t).round(), (al + bl * t).round(), 1.0)
       .toHslaString();
 }

 /// Generates an interpolator to interpolate each element between lists
 /// [a] and [b] using registered interpolators.
 Interpolator<List> createListInterpolator(List a, List b) {
   if (a == null || b == null) return (t) => b;
   var x = <Interpolator>[],
       aLength = a.length,
       numInterpolated = b.length,
       output =
           new List<dynamic>.filled(math.max(aLength, numInterpolated), null);
   num n0 = math.min(aLength, numInterpolated);
   int i;

   for (i = 0; i < n0; i++) x.add(createInterpolatorFromRegistry(a[i], b[i]));
   for (; i < aLength; ++i) output[i] = a[i];
   for (; i < numInterpolated; ++i) output[i] = b[i];

   return (num t) {
     for (i = 0; i < n0; ++i) output[i] = x[i](t);
     return output;
   };
 }

 /// Generates an interpolator to interpolate each value on [a] to [b] using
 /// registered interpolators.
 Interpolator<Map> createMapInterpolator(Map a, Map b) {
   if (a == null || b == null) return (t) => b;
   var interpolatorsMap = new Map(),
       output = new Map(),
       aKeys = a.keys.toList(),
       bKeys = b.keys.toList();

   aKeys.forEach((k) {
     if (b[k] != null) {
       interpolatorsMap[k] = (createInterpolatorFromRegistry(a[k], b[k]));
     } else {
       output[k] = a[k];
     }
   });

   bKeys.forEach((k) {
     if (output[k] == null) {
       output[k] = b[k];
     }
   });

   return (t) {
     interpolatorsMap.forEach((k, v) => output[k] = v(t));
     return output;
   };
 }

 /// Returns the interpolator that interpolators two transform strings
 /// [a] and [b] by their translate, rotate, scale and skewX parts.
 Interpolator<String> createTransformInterpolator(String a, String b) {
   if (a == null || b == null) return (t) => b;
   var numRegExStr = r'[-+]?(?:\d+\.?\d*|\.?\d+)(?:[eE][-+]?\d+)?',
       numberRegEx = new RegExp(numRegExStr),
       translateRegEx =
           new RegExp(r'translate\(' + '$numRegExStr,$numRegExStr' + r'\)'),
       scaleRegEx =
           new RegExp(r'scale\(' + numRegExStr + r',' + numRegExStr + r'\)'),
       rotateRegEx = new RegExp(r'rotate\(' + numRegExStr + r'(deg)?\)'),
       skewRegEx = new RegExp(r'skewX\(' + numRegExStr + r'(deg)?\)'),
       translateA = translateRegEx.firstMatch(a),
       scaleA = scaleRegEx.firstMatch(a),
       rotateA = rotateRegEx.firstMatch(a),
       skewA = skewRegEx.firstMatch(a),
       translateB = translateRegEx.firstMatch(b),
       scaleB = scaleRegEx.firstMatch(b),
       rotateB = rotateRegEx.firstMatch(b),
       skewB = skewRegEx.firstMatch(b);

   List<num> numSetA = [], numSetB = [];
   String tempStr;

   // translate
   if (translateA != null) {
     tempStr = a.substring(translateA.start, translateA.end);
     var match = numberRegEx.allMatches(tempStr);
     for (Match m in match) {
       numSetA.add(num.parse(m.group(0)));
     }
   } else {
     numSetA.addAll(const [0, 0]);
   }

   if (translateB != null) {
     tempStr = b.substring(translateB.start, translateB.end);
     var match = numberRegEx.allMatches(tempStr);
     for (Match m in match) {
       numSetB.add(num.parse(m.group(0)));
     }
   } else {
     numSetB.addAll(const [0, 0]);
   }

   // scale
   if (scaleA != null) {
     tempStr = a.substring(scaleA.start, scaleA.end);
     var match = numberRegEx.allMatches(tempStr);
     for (Match m in match) {
       numSetA.add(num.parse(m.group(0)));
     }
   } else {
     numSetA.addAll(const [1, 1]);
   }

   if (scaleB != null) {
     tempStr = b.substring(scaleB.start, scaleB.end);
     var match = numberRegEx.allMatches(tempStr);
     for (Match m in match) {
       numSetB.add(num.parse(m.group(0)));
     }
   } else {
     numSetB.addAll(const [1, 1]);
   }

   // rotate
   if (rotateA != null) {
     tempStr = a.substring(rotateA.start, rotateA.end);
     var match = numberRegEx.firstMatch(tempStr);
     numSetA.add(num.parse(match.group(0)));
   } else {
     numSetA.add(0);
   }

   if (rotateB != null) {
     tempStr = b.substring(rotateB.start, rotateB.end);
     var match = numberRegEx.firstMatch(tempStr);
     numSetB.add(num.parse(match.group(0)));
   } else {
     numSetB.add(0);
   }

   // rotate < 180 degree
   if (numSetA[4] != numSetB[4]) {
     if (numSetA[4] - numSetB[4] > 180) {
       numSetB[4] += 360;
     } else if (numSetB[4] - numSetA[4] > 180) {
       numSetA[4] += 360;
     }
   }

   // skew
   if (skewA != null) {
     tempStr = a.substring(skewA.start, skewA.end);
     var match = numberRegEx.firstMatch(tempStr);
     numSetA.add(num.parse(match.group(0)));
   } else {
     numSetA.add(0);
   }

   if (skewB != null) {
     tempStr = b.substring(skewB.start, skewB.end);
     var match = numberRegEx.firstMatch(tempStr);
     numSetB.add(num.parse(match.group(0)));
   } else {
     numSetB.add(0);
   }

   return (num t) {
     return 'translate(${createNumberInterpolator(numSetA[0], numSetB[0])(t)},'
         '${createNumberInterpolator(numSetA[1], numSetB[1])(t)})'
         'scale(${createNumberInterpolator(numSetA[2], numSetB[2])(t)},'
         '${createNumberInterpolator(numSetA[3], numSetB[3])(t)})'
         'rotate(${createNumberInterpolator(numSetA[4], numSetB[4])(t)})'
         'skewX(${createNumberInterpolator(numSetA[5], numSetB[5])(t)})';
   };
 }

 /// Returns the interpolator that interpolators zoom list [a] to [b]. Zoom
 /// lists are described by triple elements [ux0, uy0, w0] and [ux1, uy1, w1].
 Interpolator<List<num>> createZoomInterpolator(List a, List b) {
   if (a == null || b == null) return (t) => b;
   assert(a.length == b.length && a.length == 3);

   var sqrt2 = math.SQRT2, param2 = 2, param4 = 4;

   num ux0 = a[0], uy0 = a[1], w0 = a[2], ux1 = b[0], uy1 = b[1], w1 = b[2];

   num dx = ux1 - ux0,
       dy = uy1 - uy0,
       d2 = dx * dx + dy * dy,
       d1 = math.sqrt(d2),
       b0 = (w1 * w1 - w0 * w0 + param4 * d2) / (2 * w0 * param2 * d1),
       b1 = (w1 * w1 - w0 * w0 - param4 * d2) / (2 * w1 * param2 * d1),
       r0 = math.log(math.sqrt(b0 * b0 + 1) - b0),
       r1 = math.log(math.sqrt(b1 * b1 + 1) - b1),
       dr = r1 - r0,
       S = ((!dr.isNaN) ? dr : math.log(w1 / w0)) / sqrt2;

   return (num t) {
     var s = t * S;
     if (!dr.isNaN) {
       // General case.
       var coshr0 = cosh(r0),
           u = w0 / (param2 * d1) * (coshr0 * tanh(sqrt2 * s + r0) - sinh(r0));
       return [ux0 + u * dx, uy0 + u * dy, w0 * coshr0 / cosh(sqrt2 * s + r0)];
     }
     // Special case for u0 ~= u1.
     return <num>[ux0 + t * dx, uy0 + t * dy, w0 * math.exp(sqrt2 * s)];
   };
 }

 /// Reverse interpolator for a number.
 Interpolator<num> uninterpolateNumber(num a, num b) {
   b = 1 / (b - a);
   return (x) => (x - a) * b;
 }

 /// Reverse interpolator for a clamped number.
 Interpolator<num> uninterpolateClamp(num a, num b) {
   b = 1 / (b - a);
   return (x) => math.max(0, math.min(1, (x - a) * b));
 }
	//
	// Copyright 2014 Google Inc. All rights reserved.
	//
	// Use of this source code is governed by a BSD-style
	// license that can be found in the LICENSE file or at
	// https://developers.google.com/open-source/licenses/bsd
	//

	part of charted.core.interpolators;

	/// [Interpolator] accepts [t], such that 0.0 < t < 1.0 and returns
	/// a value in a pre-defined range.
	typedef Interpolator<S> = S Function(num t);

	/// [InterpolatorGenerator] accepts two parameters [a], [b] and returns an
	/// [Interpolator] for transitioning from [a] to [b]
	typedef InterpolatorGenerator<T, S> = Interpolator<S> Function(T a, T b);

	/// List of registered interpolators - [createInterpolatorFromRegistry]
	/// iterates through this list from backwards and the first non-null
	/// interpolate function is returned to the caller.
	List<InterpolatorGenerator> _interpolators = [createInterpolatorByType];

	/// Returns a default interpolator between values [a] and [b]. Unless
	/// more interpolators are added, one of the internal implementations are
	/// selected by the type of [a] and [b].
	Interpolator createInterpolatorFromRegistry(a, b) {
	Interpolator fn;
	int i = _interpolators.length;
	while (--i >= 0 && fn == null) {
	fn = _interpolators[i](a, b);
	}
	return fn;
	}

	/// Creates an interpolator based on the type of [a] and [b].
	///
	/// Usage note: Use this method only when type of [a] and [b] are not known.
	/// When used, this function will prevent tree shaking of all built-in
	/// interpolators.
	Interpolator createInterpolatorByType(a, b) {
	if (a is List && b is List) {
	return createListInterpolator(a, b);
	} else if (a is Map && b is Map) {
	return createMapInterpolator(a, b);
	} else if (a is String && b is String) {
	return createStringInterpolator(a, b);
	} else if (a is num && b is num) {
	return createNumberInterpolator(a, b);
	} else if (a is Color && b is Color) {
	return createRgbColorInterpolator(a, b);
	} else {
	return (t) => (t <= 0.5) ? a : b;
	}
	}

	//
	// Implementations of InterpolatorGenerator
	//

	/// Generate a numeric interpolator between numbers [a] and [b]
	Interpolator<num> createNumberInterpolator(num a, num b) {
	b -= a;
	return (t) => a + b * t;
	}

	/// Generate a rounded number interpolator between numbers [a] and [b]
	Interpolator<num> createRoundedNumberInterpolator(num a, num b) {
	b -= a;
	return (t) => (a + b * t).round();
	}

	/// Generate an interpolator between two strings [a] and [b].
	///
	/// The interpolator will interpolate all the number pairs in both strings
	/// that have same number of numeric parts. The function assumes the non
	/// number part of the string to be identical and would use string [b] for
	/// merging the non numeric part of the strings.
	///
	/// Eg: Interpolate between $100.0 and $150.0
	Interpolator<String> createStringInterpolator(String a, String b) {
	if (a == null \|\| b == null) return (num t) => b;

	// See if both A and B represent colors as RGB or HEX strings.
	// If yes, use color interpolators
	if (Color.isRgbColorString(a) && Color.isRgbColorString(b)) {
	return createRgbColorInterpolator(
	new Color.fromRgbString(a), new Color.fromRgbString(b));
	}

	// See if both A and B represent colors as HSL strings.
	// If yes, use color interpolators.
	if (Color.isHslColorString(a) && Color.isHslColorString(b)) {
	return createHslColorInterpolator(
	new Color.fromHslString(a), new Color.fromHslString(b));
	}

	var numberRegEx = new RegExp(r'[-+]?(?:\d+\.?\d*\|\.?\d+)(?:[eE][-+]?\d+)?');
	var numMatchesInA = numberRegEx.allMatches(a);
	var numMatchesInB = numberRegEx.allMatches(b);
	List<String> stringParts = [];
	List<String> numberPartsInA = [];
	List<String> numberPartsInB = [];
	List<Interpolator<num>> interpolators = [];
	int s0 = 0;

	numberPartsInA.addAll(numMatchesInA.map((m) => m.group(0)));

	for (Match m in numMatchesInB) {
	stringParts.add(b.substring(s0, m.start));
	numberPartsInB.add(m.group(0));
	s0 = m.end;
	}

	if (s0 < b.length) stringParts.add(b.substring(s0));

	int numberLength = math.min(numberPartsInA.length, numberPartsInB.length);
	int maxLength = math.max(numberPartsInA.length, numberPartsInB.length);
	for (var i = 0; i < numberLength; i++) {
	interpolators.add(createNumberInterpolator(
	num.parse(numberPartsInA[i]), num.parse(numberPartsInB[i])));
	}
	if (numberPartsInA.length < numberPartsInB.length) {
	for (var i = numberLength; i < maxLength; i++) {
	interpolators.add(createNumberInterpolator(
	num.parse(numberPartsInB[i]), num.parse(numberPartsInB[i])));
	}
	}

	return (num t) {
	StringBuffer sb = new StringBuffer();
	for (var i = 0; i < stringParts.length; i++) {
	sb.write(stringParts[i]);
	if (interpolators.length > i) {
	sb.write(interpolators[i](t));
	}
	}
	return sb.toString();
	};
	}

	/// Generate an interpolator for RGB values.
	Interpolator<String> createRgbColorInterpolator(Color a, Color b) {
	if (a == null \|\| b == null) return (num t) => b.toRgbaString();
	var ar = a.r, ag = a.g, ab = a.b, br = b.r - ar, bg = b.g - ag, bb = b.b - ab;

	return (num t) => new Color.fromRgba((ar + br * t).round(),
	(ag + bg * t).round(), (ab + bb * t).round(), 1.0)
	.toRgbaString();
	}

	/// Generate an interpolator using HSL color system converted to Hex string.
	Interpolator<String> createHslColorInterpolator(Color a, Color b) {
	if (a == null \|\| b == null) return (num t) => b.toHslaString();
	var ah = a.h, as = a.s, al = a.l, bh = b.h - ah, bs = b.s - as, bl = b.l - al;

	return (num t) => new Color.fromHsla((ah + bh * t).round(),
	(as + bs * t).round(), (al + bl * t).round(), 1.0)
	.toHslaString();
	}

	/// Generates an interpolator to interpolate each element between lists
	/// [a] and [b] using registered interpolators.
	Interpolator<List> createListInterpolator(List a, List b) {
	if (a == null \|\| b == null) return (t) => b;
	var x = <Interpolator>[],
	aLength = a.length,
	numInterpolated = b.length,
	output =
	new List<dynamic>.filled(math.max(aLength, numInterpolated), null);
	num n0 = math.min(aLength, numInterpolated);
	int i;

	for (i = 0; i < n0; i++) x.add(createInterpolatorFromRegistry(a[i], b[i]));
	for (; i < aLength; ++i) output[i] = a[i];
	for (; i < numInterpolated; ++i) output[i] = b[i];

	return (num t) {
	for (i = 0; i < n0; ++i) output[i] = x[i](t);
	return output;
	};
	}

	/// Generates an interpolator to interpolate each value on [a] to [b] using
	/// registered interpolators.
	Interpolator<Map> createMapInterpolator(Map a, Map b) {
	if (a == null \|\| b == null) return (t) => b;
	var interpolatorsMap = new Map(),
	output = new Map(),
	aKeys = a.keys.toList(),
	bKeys = b.keys.toList();

	aKeys.forEach((k) {
	if (b[k] != null) {
	interpolatorsMap[k] = (createInterpolatorFromRegistry(a[k], b[k]));
	} else {
	output[k] = a[k];
	}
	});

	bKeys.forEach((k) {
	if (output[k] == null) {
	output[k] = b[k];
	}
	});

	return (t) {
	interpolatorsMap.forEach((k, v) => output[k] = v(t));
	return output;
	};
	}

	/// Returns the interpolator that interpolators two transform strings
	/// [a] and [b] by their translate, rotate, scale and skewX parts.
	Interpolator<String> createTransformInterpolator(String a, String b) {
	if (a == null \|\| b == null) return (t) => b;
	var numRegExStr = r'[-+]?(?:\d+\.?\d*\|\.?\d+)(?:[eE][-+]?\d+)?',
	numberRegEx = new RegExp(numRegExStr),
	translateRegEx =
	new RegExp(r'translate\(' + '$numRegExStr,$numRegExStr' + r'\)'),
	scaleRegEx =
	new RegExp(r'scale\(' + numRegExStr + r',' + numRegExStr + r'\)'),
	rotateRegEx = new RegExp(r'rotate\(' + numRegExStr + r'(deg)?\)'),
	skewRegEx = new RegExp(r'skewX\(' + numRegExStr + r'(deg)?\)'),
	translateA = translateRegEx.firstMatch(a),
	scaleA = scaleRegEx.firstMatch(a),
	rotateA = rotateRegEx.firstMatch(a),
	skewA = skewRegEx.firstMatch(a),
	translateB = translateRegEx.firstMatch(b),
	scaleB = scaleRegEx.firstMatch(b),
	rotateB = rotateRegEx.firstMatch(b),
	skewB = skewRegEx.firstMatch(b);

	List<num> numSetA = [], numSetB = [];
	String tempStr;

	// translate
	if (translateA != null) {
	tempStr = a.substring(translateA.start, translateA.end);
	var match = numberRegEx.allMatches(tempStr);
	for (Match m in match) {
	numSetA.add(num.parse(m.group(0)));
	}
	} else {
	numSetA.addAll(const [0, 0]);
	}

	if (translateB != null) {
	tempStr = b.substring(translateB.start, translateB.end);
	var match = numberRegEx.allMatches(tempStr);
	for (Match m in match) {
	numSetB.add(num.parse(m.group(0)));
	}
	} else {
	numSetB.addAll(const [0, 0]);
	}

	// scale
	if (scaleA != null) {
	tempStr = a.substring(scaleA.start, scaleA.end);
	var match = numberRegEx.allMatches(tempStr);
	for (Match m in match) {
	numSetA.add(num.parse(m.group(0)));
	}
	} else {
	numSetA.addAll(const [1, 1]);
	}

	if (scaleB != null) {
	tempStr = b.substring(scaleB.start, scaleB.end);
	var match = numberRegEx.allMatches(tempStr);
	for (Match m in match) {
	numSetB.add(num.parse(m.group(0)));
	}
	} else {
	numSetB.addAll(const [1, 1]);
	}

	// rotate
	if (rotateA != null) {
	tempStr = a.substring(rotateA.start, rotateA.end);
	var match = numberRegEx.firstMatch(tempStr);
	numSetA.add(num.parse(match.group(0)));
	} else {
	numSetA.add(0);
	}

	if (rotateB != null) {
	tempStr = b.substring(rotateB.start, rotateB.end);
	var match = numberRegEx.firstMatch(tempStr);
	numSetB.add(num.parse(match.group(0)));
	} else {
	numSetB.add(0);
	}

	// rotate < 180 degree
	if (numSetA[4] != numSetB[4]) {
	if (numSetA[4] - numSetB[4] > 180) {
	numSetB[4] += 360;
	} else if (numSetB[4] - numSetA[4] > 180) {
	numSetA[4] += 360;
	}
	}

	// skew
	if (skewA != null) {
	tempStr = a.substring(skewA.start, skewA.end);
	var match = numberRegEx.firstMatch(tempStr);
	numSetA.add(num.parse(match.group(0)));
	} else {
	numSetA.add(0);
	}

	if (skewB != null) {
	tempStr = b.substring(skewB.start, skewB.end);
	var match = numberRegEx.firstMatch(tempStr);
	numSetB.add(num.parse(match.group(0)));
	} else {
	numSetB.add(0);
	}

	return (num t) {
	return 'translate(${createNumberInterpolator(numSetA[0], numSetB[0])(t)},'
	'${createNumberInterpolator(numSetA[1], numSetB[1])(t)})'
	'scale(${createNumberInterpolator(numSetA[2], numSetB[2])(t)},'
	'${createNumberInterpolator(numSetA[3], numSetB[3])(t)})'
	'rotate(${createNumberInterpolator(numSetA[4], numSetB[4])(t)})'
	'skewX(${createNumberInterpolator(numSetA[5], numSetB[5])(t)})';
	};
	}

	/// Returns the interpolator that interpolators zoom list [a] to [b]. Zoom
	/// lists are described by triple elements [ux0, uy0, w0] and [ux1, uy1, w1].
	Interpolator<List<num>> createZoomInterpolator(List a, List b) {
	if (a == null \|\| b == null) return (t) => b;
	assert(a.length == b.length && a.length == 3);

	var sqrt2 = math.SQRT2, param2 = 2, param4 = 4;

	num ux0 = a[0], uy0 = a[1], w0 = a[2], ux1 = b[0], uy1 = b[1], w1 = b[2];

	num dx = ux1 - ux0,
	dy = uy1 - uy0,
	d2 = dx * dx + dy * dy,
	d1 = math.sqrt(d2),
	b0 = (w1 * w1 - w0 * w0 + param4 * d2) / (2 * w0 * param2 * d1),
	b1 = (w1 * w1 - w0 * w0 - param4 * d2) / (2 * w1 * param2 * d1),
	r0 = math.log(math.sqrt(b0 * b0 + 1) - b0),
	r1 = math.log(math.sqrt(b1 * b1 + 1) - b1),
	dr = r1 - r0,
	S = ((!dr.isNaN) ? dr : math.log(w1 / w0)) / sqrt2;

	return (num t) {
	var s = t * S;
	if (!dr.isNaN) {
	// General case.
	var coshr0 = cosh(r0),
	u = w0 / (param2 * d1) * (coshr0 * tanh(sqrt2 * s + r0) - sinh(r0));
	return [ux0 + u * dx, uy0 + u * dy, w0 * coshr0 / cosh(sqrt2 * s + r0)];
	}
	// Special case for u0 ~= u1.
	return <num>[ux0 + t * dx, uy0 + t * dy, w0 * math.exp(sqrt2 * s)];
	};
	}

	/// Reverse interpolator for a number.
	Interpolator<num> uninterpolateNumber(num a, num b) {
	b = 1 / (b - a);
	return (x) => (x - a) * b;
	}

	/// Reverse interpolator for a clamped number.
	Interpolator<num> uninterpolateClamp(num a, num b) {
	b = 1 / (b - a);
	return (x) => math.max(0, math.min(1, (x - a) * b));
	}