2013-05-01 08:46:16 +04:00
|
|
|
/*
|
2013-05-14 08:00:24 +04:00
|
|
|
* OpenSeadragon - Spring
|
2013-05-01 08:46:16 +04:00
|
|
|
*
|
|
|
|
* Copyright (C) 2009 CodePlex Foundation
|
2013-05-14 07:32:09 +04:00
|
|
|
* Copyright (C) 2010-2013 OpenSeadragon contributors
|
2013-05-01 08:46:16 +04:00
|
|
|
*
|
|
|
|
* Redistribution and use in source and binary forms, with or without
|
|
|
|
* modification, are permitted provided that the following conditions are
|
|
|
|
* met:
|
|
|
|
*
|
|
|
|
* - Redistributions of source code must retain the above copyright notice,
|
|
|
|
* this list of conditions and the following disclaimer.
|
|
|
|
*
|
|
|
|
* - Redistributions in binary form must reproduce the above copyright
|
|
|
|
* notice, this list of conditions and the following disclaimer in the
|
|
|
|
* documentation and/or other materials provided with the distribution.
|
|
|
|
*
|
|
|
|
* - Neither the name of CodePlex Foundation nor the names of its
|
|
|
|
* contributors may be used to endorse or promote products derived from
|
|
|
|
* this software without specific prior written permission.
|
|
|
|
*
|
|
|
|
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
|
|
|
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
|
|
|
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
|
|
|
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
|
|
|
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
|
|
|
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
|
|
|
|
* TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
|
|
|
|
* PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
|
|
|
|
* LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
|
|
|
|
* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
|
|
|
|
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
|
|
*/
|
|
|
|
|
2011-12-06 07:50:25 +04:00
|
|
|
(function( $ ){
|
2013-06-19 21:33:25 +04:00
|
|
|
|
2012-01-25 23:14:02 +04:00
|
|
|
/**
|
2013-11-16 10:19:53 +04:00
|
|
|
* @class Spring
|
|
|
|
* @memberof OpenSeadragon
|
2012-02-15 23:50:27 +04:00
|
|
|
* @param {Object} options - Spring configuration settings.
|
2015-03-31 00:50:37 +03:00
|
|
|
* @param {Number} options.springStiffness - Spring stiffness. Must be greater than zero.
|
|
|
|
* The closer to zero, the closer to linear animation.
|
|
|
|
* @param {Number} options.animationTime - Animation duration per spring, in seconds.
|
2016-01-15 20:19:18 +03:00
|
|
|
* Must be zero or greater.
|
2015-03-31 00:50:37 +03:00
|
|
|
* @param {Number} [options.initial=0] - Initial value of spring.
|
|
|
|
* @param {Boolean} [options.exponential=false] - Whether this spring represents
|
|
|
|
* an exponential scale (such as zoom) and should be animated accordingly. Note that
|
|
|
|
* exponential springs must have non-zero values.
|
2012-01-25 23:14:02 +04:00
|
|
|
*/
|
2011-12-30 03:16:51 +04:00
|
|
|
$.Spring = function( options ) {
|
|
|
|
var args = arguments;
|
|
|
|
|
|
|
|
if( typeof( options ) != 'object' ){
|
2013-06-19 21:33:25 +04:00
|
|
|
//allows backward compatible use of ( initialValue, config ) as
|
2011-12-30 03:16:51 +04:00
|
|
|
//constructor parameters
|
|
|
|
options = {
|
2013-06-19 21:33:25 +04:00
|
|
|
initial: args.length && typeof ( args[ 0 ] ) == "number" ?
|
|
|
|
args[ 0 ] :
|
2015-03-31 00:50:37 +03:00
|
|
|
undefined,
|
2013-11-25 20:48:44 +04:00
|
|
|
/**
|
|
|
|
* Spring stiffness.
|
|
|
|
* @member {Number} springStiffness
|
|
|
|
* @memberof OpenSeadragon.Spring#
|
|
|
|
*/
|
2013-06-19 21:33:25 +04:00
|
|
|
springStiffness: args.length > 1 ?
|
|
|
|
args[ 1 ].springStiffness :
|
2011-12-30 03:16:51 +04:00
|
|
|
5.0,
|
2013-11-25 20:48:44 +04:00
|
|
|
/**
|
|
|
|
* Animation duration per spring.
|
|
|
|
* @member {Number} animationTime
|
|
|
|
* @memberof OpenSeadragon.Spring#
|
|
|
|
*/
|
2013-06-19 21:33:25 +04:00
|
|
|
animationTime: args.length > 1 ?
|
|
|
|
args[ 1 ].animationTime :
|
2012-03-20 23:00:25 +04:00
|
|
|
1.5
|
2011-12-30 03:16:51 +04:00
|
|
|
};
|
|
|
|
}
|
|
|
|
|
2015-03-31 00:50:37 +03:00
|
|
|
$.console.assert(typeof options.springStiffness === "number" && options.springStiffness !== 0,
|
|
|
|
"[OpenSeadragon.Spring] options.springStiffness must be a non-zero number");
|
|
|
|
|
2016-01-15 20:19:18 +03:00
|
|
|
$.console.assert(typeof options.animationTime === "number" && options.animationTime >= 0,
|
|
|
|
"[OpenSeadragon.Spring] options.animationTime must be a number greater than or equal to 0");
|
2015-03-31 00:50:37 +03:00
|
|
|
|
|
|
|
if (options.exponential) {
|
|
|
|
this._exponential = true;
|
|
|
|
delete options.exponential;
|
2015-03-18 02:43:25 +03:00
|
|
|
}
|
|
|
|
|
2011-12-30 03:18:09 +04:00
|
|
|
$.extend( true, this, options);
|
2011-12-30 03:16:51 +04:00
|
|
|
|
2013-11-25 20:48:44 +04:00
|
|
|
/**
|
|
|
|
* @member {Object} current
|
|
|
|
* @memberof OpenSeadragon.Spring#
|
|
|
|
* @property {Number} value
|
|
|
|
* @property {Number} time
|
|
|
|
*/
|
2012-01-04 02:54:20 +04:00
|
|
|
this.current = {
|
2013-06-19 21:33:25 +04:00
|
|
|
value: typeof ( this.initial ) == "number" ?
|
|
|
|
this.initial :
|
2015-03-31 00:50:37 +03:00
|
|
|
(this._exponential ? 0 : 1),
|
2013-06-21 00:15:04 +04:00
|
|
|
time: $.now() // always work in milliseconds
|
2012-01-05 03:14:20 +04:00
|
|
|
};
|
2012-01-04 02:54:20 +04:00
|
|
|
|
2015-03-31 00:50:37 +03:00
|
|
|
$.console.assert(!this._exponential || this.current.value !== 0,
|
|
|
|
"[OpenSeadragon.Spring] value must be non-zero for exponential springs");
|
|
|
|
|
2013-11-25 20:48:44 +04:00
|
|
|
/**
|
|
|
|
* @member {Object} start
|
|
|
|
* @memberof OpenSeadragon.Spring#
|
|
|
|
* @property {Number} value
|
|
|
|
* @property {Number} time
|
|
|
|
*/
|
2012-01-05 03:14:20 +04:00
|
|
|
this.start = {
|
|
|
|
value: this.current.value,
|
|
|
|
time: this.current.time
|
|
|
|
};
|
2011-12-06 07:50:25 +04:00
|
|
|
|
2013-11-25 20:48:44 +04:00
|
|
|
/**
|
|
|
|
* @member {Object} target
|
|
|
|
* @memberof OpenSeadragon.Spring#
|
|
|
|
* @property {Number} value
|
|
|
|
* @property {Number} time
|
|
|
|
*/
|
2012-01-05 03:14:20 +04:00
|
|
|
this.target = {
|
|
|
|
value: this.current.value,
|
|
|
|
time: this.current.time
|
|
|
|
};
|
2015-03-18 02:43:25 +03:00
|
|
|
|
2015-03-31 00:50:37 +03:00
|
|
|
if (this._exponential) {
|
2015-03-18 02:43:25 +03:00
|
|
|
this.start._logValue = Math.log(this.start.value);
|
|
|
|
this.target._logValue = Math.log(this.target.value);
|
|
|
|
this.current._logValue = Math.log(this.current.value);
|
|
|
|
}
|
2011-12-06 07:50:25 +04:00
|
|
|
};
|
|
|
|
|
2016-01-25 00:09:18 +03:00
|
|
|
/** @lends OpenSeadragon.Spring.prototype */
|
|
|
|
$.Spring.prototype = {
|
2011-12-06 07:50:25 +04:00
|
|
|
|
2012-02-15 23:50:27 +04:00
|
|
|
/**
|
|
|
|
* @function
|
|
|
|
* @param {Number} target
|
|
|
|
*/
|
2012-01-05 03:14:20 +04:00
|
|
|
resetTo: function( target ) {
|
2015-03-31 00:50:37 +03:00
|
|
|
$.console.assert(!this._exponential || target !== 0,
|
|
|
|
"[OpenSeadragon.Spring.resetTo] target must be non-zero for exponential springs");
|
|
|
|
|
2015-01-20 22:23:34 +03:00
|
|
|
this.start.value = this.target.value = this.current.value = target;
|
|
|
|
this.start.time = this.target.time = this.current.time = $.now();
|
2015-03-18 02:43:25 +03:00
|
|
|
|
2015-03-31 00:50:37 +03:00
|
|
|
if (this._exponential) {
|
2015-03-18 02:43:25 +03:00
|
|
|
this.start._logValue = Math.log(this.start.value);
|
|
|
|
this.target._logValue = Math.log(this.target.value);
|
|
|
|
this.current._logValue = Math.log(this.current.value);
|
|
|
|
}
|
2011-12-06 07:50:25 +04:00
|
|
|
},
|
|
|
|
|
2012-02-15 23:50:27 +04:00
|
|
|
/**
|
|
|
|
* @function
|
|
|
|
* @param {Number} target
|
|
|
|
*/
|
2012-01-05 03:14:20 +04:00
|
|
|
springTo: function( target ) {
|
2015-03-31 00:50:37 +03:00
|
|
|
$.console.assert(!this._exponential || target !== 0,
|
|
|
|
"[OpenSeadragon.Spring.springTo] target must be non-zero for exponential springs");
|
|
|
|
|
2012-01-05 03:14:20 +04:00
|
|
|
this.start.value = this.current.value;
|
|
|
|
this.start.time = this.current.time;
|
|
|
|
this.target.value = target;
|
|
|
|
this.target.time = this.start.time + 1000 * this.animationTime;
|
2015-03-18 02:43:25 +03:00
|
|
|
|
2015-03-31 00:50:37 +03:00
|
|
|
if (this._exponential) {
|
2015-03-18 02:43:25 +03:00
|
|
|
this.start._logValue = Math.log(this.start.value);
|
|
|
|
this.target._logValue = Math.log(this.target.value);
|
|
|
|
}
|
2011-12-06 07:50:25 +04:00
|
|
|
},
|
|
|
|
|
2012-02-15 23:50:27 +04:00
|
|
|
/**
|
|
|
|
* @function
|
|
|
|
* @param {Number} delta
|
|
|
|
*/
|
2012-01-05 03:14:20 +04:00
|
|
|
shiftBy: function( delta ) {
|
|
|
|
this.start.value += delta;
|
|
|
|
this.target.value += delta;
|
2015-03-18 02:43:25 +03:00
|
|
|
|
2015-03-31 00:50:37 +03:00
|
|
|
if (this._exponential) {
|
|
|
|
$.console.assert(this.target.value !== 0 && this.start.value !== 0,
|
|
|
|
"[OpenSeadragon.Spring.shiftBy] spring value must be non-zero for exponential springs");
|
|
|
|
|
2015-03-18 02:43:25 +03:00
|
|
|
this.start._logValue = Math.log(this.start.value);
|
|
|
|
this.target._logValue = Math.log(this.target.value);
|
|
|
|
}
|
|
|
|
},
|
|
|
|
|
2015-03-31 00:50:37 +03:00
|
|
|
setExponential: function(value) {
|
|
|
|
this._exponential = value;
|
|
|
|
|
|
|
|
if (this._exponential) {
|
|
|
|
$.console.assert(this.current.value !== 0 && this.target.value !== 0 && this.start.value !== 0,
|
|
|
|
"[OpenSeadragon.Spring.setExponential] spring value must be non-zero for exponential springs");
|
2015-03-18 02:43:25 +03:00
|
|
|
|
|
|
|
this.start._logValue = Math.log(this.start.value);
|
|
|
|
this.target._logValue = Math.log(this.target.value);
|
|
|
|
this.current._logValue = Math.log(this.current.value);
|
|
|
|
}
|
2011-12-06 07:50:25 +04:00
|
|
|
},
|
|
|
|
|
2012-02-15 23:50:27 +04:00
|
|
|
/**
|
|
|
|
* @function
|
|
|
|
*/
|
2011-12-06 07:50:25 +04:00
|
|
|
update: function() {
|
2013-06-21 00:15:04 +04:00
|
|
|
this.current.time = $.now();
|
2015-03-18 02:43:25 +03:00
|
|
|
|
|
|
|
var startValue, targetValue;
|
2015-03-31 00:50:37 +03:00
|
|
|
if (this._exponential) {
|
2015-03-18 02:43:25 +03:00
|
|
|
startValue = this.start._logValue;
|
|
|
|
targetValue = this.target._logValue;
|
|
|
|
} else {
|
|
|
|
startValue = this.start.value;
|
|
|
|
targetValue = this.target.value;
|
|
|
|
}
|
|
|
|
|
|
|
|
var currentValue = (this.current.time >= this.target.time) ?
|
|
|
|
targetValue :
|
|
|
|
startValue +
|
|
|
|
( targetValue - startValue ) *
|
2013-06-19 21:33:25 +04:00
|
|
|
transform(
|
|
|
|
this.springStiffness,
|
|
|
|
( this.current.time - this.start.time ) /
|
2012-01-05 03:14:20 +04:00
|
|
|
( this.target.time - this.start.time )
|
2012-01-04 02:44:52 +04:00
|
|
|
);
|
2015-03-18 02:43:25 +03:00
|
|
|
|
2015-03-31 00:50:37 +03:00
|
|
|
if (this._exponential) {
|
2015-03-18 02:43:25 +03:00
|
|
|
this.current.value = Math.exp(currentValue);
|
|
|
|
} else {
|
|
|
|
this.current.value = currentValue;
|
|
|
|
}
|
2011-12-06 07:50:25 +04:00
|
|
|
}
|
2013-01-29 21:32:58 +04:00
|
|
|
};
|
2011-12-06 07:50:25 +04:00
|
|
|
|
2012-02-15 23:50:27 +04:00
|
|
|
/**
|
|
|
|
* @private
|
|
|
|
*/
|
2011-12-30 03:16:51 +04:00
|
|
|
function transform( stiffness, x ) {
|
2013-06-19 21:33:25 +04:00
|
|
|
return ( 1.0 - Math.exp( stiffness * -x ) ) /
|
2011-12-30 03:16:51 +04:00
|
|
|
( 1.0 - Math.exp( -stiffness ) );
|
2013-01-29 21:32:58 +04:00
|
|
|
}
|
2011-12-30 03:16:51 +04:00
|
|
|
|
2011-12-06 07:50:25 +04:00
|
|
|
}( OpenSeadragon ));
|