Christoph Oberhofer
10 years ago
commit
94a9e54f0c
File diff suppressed because one or more lines are too long
File diff suppressed because one or more lines are too long
@ -0,0 +1,21 @@
|
||||
var Quagga = require('../lib/quagga');
|
||||
|
||||
Quagga.decodeSingle({
|
||||
src: "../test/fixtures/code_128/image-001.jpg",
|
||||
numOfWorkers: 0,
|
||||
inputStream: {
|
||||
size: 800,
|
||||
area: {
|
||||
top: "10%",
|
||||
right: "5%",
|
||||
left: "5%",
|
||||
bottom: "10%"
|
||||
}
|
||||
}
|
||||
}, function(result) {
|
||||
if(result.codeResult) {
|
||||
console.log("result", result.codeResult.code);
|
||||
} else {
|
||||
console.log("not detected");
|
||||
}
|
||||
});
|
||||
@ -0,0 +1,101 @@
|
||||
/* jshint undef: true, unused: true, browser:true, devel: true */
|
||||
/* global define */
|
||||
|
||||
define(["cv_utils"], function(CVUtils) {
|
||||
"use strict";
|
||||
|
||||
var Ndarray = require("ndarray"),
|
||||
Interp2D = require("ndarray-linear-interpolate").d2;
|
||||
|
||||
var FrameGrabber = {};
|
||||
|
||||
FrameGrabber.create = function(inputStream) {
|
||||
var _that = {},
|
||||
_streamConfig = inputStream.getConfig(),
|
||||
_video_size = CVUtils.imageRef(inputStream.getRealWidth(), inputStream.getRealHeight()),
|
||||
_canvasSize = inputStream.getCanvasSize(),
|
||||
_size = CVUtils.imageRef(inputStream.getWidth(), inputStream.getHeight()),
|
||||
_topRight = inputStream.getTopRight(),
|
||||
_data = new Uint8Array(_size.x * _size.y),
|
||||
_grayData = new Uint8Array(_video_size.x * _video_size.y),
|
||||
_canvasData = new Uint8Array(_canvasSize.x * _canvasSize.y),
|
||||
_grayImageArray = Ndarray(_grayData, [_video_size.y, _video_size.x]).transpose(1, 0),
|
||||
_canvasImageArray = Ndarray(_canvasData, [_canvasSize.y, _canvasSize.x]).transpose(1, 0),
|
||||
_targetImageArray = _canvasImageArray.hi(_topRight.x + _size.x, _topRight.y + _size.y).lo(_topRight.x, _topRight.y),
|
||||
_stepSizeX = _video_size.x/_canvasSize.x,
|
||||
_stepSizeY = _video_size.y/_canvasSize.y;
|
||||
|
||||
console.log("FrameGrabber", JSON.stringify({
|
||||
videoSize: _grayImageArray.shape,
|
||||
canvasSize: _canvasImageArray.shape,
|
||||
stepSize: [_stepSizeX, _stepSizeY],
|
||||
size: _targetImageArray.shape,
|
||||
topRight: _topRight
|
||||
}));
|
||||
|
||||
/**
|
||||
* Uses the given array as frame-buffer
|
||||
*/
|
||||
_that.attachData = function(data) {
|
||||
_data = data;
|
||||
};
|
||||
|
||||
/**
|
||||
* Returns the used frame-buffer
|
||||
*/
|
||||
_that.getData = function() {
|
||||
return _data;
|
||||
};
|
||||
|
||||
/**
|
||||
* Fetches a frame from the input-stream and puts into the frame-buffer.
|
||||
* The image-data is converted to gray-scale and then half-sampled if configured.
|
||||
*/
|
||||
_that.grab = function() {
|
||||
var frame = inputStream.getFrame();
|
||||
|
||||
if (frame) {
|
||||
this.scaleAndCrop(frame);
|
||||
return true;
|
||||
} else {
|
||||
return false;
|
||||
}
|
||||
};
|
||||
|
||||
_that.scaleAndCrop = function(frame) {
|
||||
var x,
|
||||
y;
|
||||
|
||||
// 1. compute full-sized gray image
|
||||
CVUtils.computeGray(frame.data, _grayData);
|
||||
|
||||
// 2. interpolate
|
||||
for (y = 0; y < _canvasSize.y; y++) {
|
||||
for (x = 0; x < _canvasSize.x; x++) {
|
||||
_canvasImageArray.set(x, y, (Interp2D(_grayImageArray, x * _stepSizeX, y * _stepSizeY)) | 0);
|
||||
}
|
||||
}
|
||||
|
||||
// targetImageArray must be equal to targetSize
|
||||
if (_targetImageArray.shape[0] !== _size.x ||
|
||||
_targetImageArray.shape[1] !== _size.y) {
|
||||
throw new Error("Shapes do not match!");
|
||||
}
|
||||
|
||||
// 3. crop
|
||||
for (y = 0; y < _size.y; y++) {
|
||||
for (x = 0; x < _size.x; x++) {
|
||||
_data[y * _size.x + x] = _targetImageArray.get(x, y);
|
||||
}
|
||||
}
|
||||
},
|
||||
|
||||
_that.getSize = function() {
|
||||
return _size;
|
||||
};
|
||||
|
||||
return _that;
|
||||
};
|
||||
|
||||
return (FrameGrabber);
|
||||
});
|
||||
@ -0,0 +1,160 @@
|
||||
/* jshint undef: true, unused: true, browser:true, devel: true */
|
||||
/* global define */
|
||||
|
||||
define(function() {
|
||||
"use strict";
|
||||
|
||||
var GetPixels = require("get-pixels");
|
||||
|
||||
var InputStream = {};
|
||||
|
||||
InputStream.createImageStream = function() {
|
||||
var that = {};
|
||||
var _config = null;
|
||||
|
||||
var width = 0,
|
||||
height = 0,
|
||||
frameIdx = 0,
|
||||
paused = true,
|
||||
loaded = false,
|
||||
frame = null,
|
||||
baseUrl,
|
||||
ended = false,
|
||||
size,
|
||||
calculatedWidth,
|
||||
calculatedHeight,
|
||||
_eventNames = ['canrecord', 'ended'],
|
||||
_eventHandlers = {},
|
||||
_topRight = {x: 0, y: 0},
|
||||
_canvasSize = {x: 0, y: 0};
|
||||
|
||||
function loadImages() {
|
||||
loaded = false;
|
||||
GetPixels(baseUrl, function(err, pixels) {
|
||||
if (err) {
|
||||
console.log(err);
|
||||
exit(1);
|
||||
}
|
||||
loaded = true;
|
||||
console.log(pixels.shape);
|
||||
frame = pixels;
|
||||
width = pixels.shape[0];
|
||||
height = pixels.shape[1];
|
||||
calculatedWidth = _config.size ? width/height > 1 ? _config.size : Math.floor((width/height) * _config.size) : width;
|
||||
calculatedHeight = _config.size ? width/height > 1 ? Math.floor((height/width) * _config.size) : _config.size : height;
|
||||
|
||||
_canvasSize.x = calculatedWidth;
|
||||
_canvasSize.y = calculatedHeight;
|
||||
|
||||
setTimeout(function() {
|
||||
publishEvent("canrecord", []);
|
||||
}, 0);
|
||||
});
|
||||
}
|
||||
|
||||
function publishEvent(eventName, args) {
|
||||
var j,
|
||||
handlers = _eventHandlers[eventName];
|
||||
|
||||
if (handlers && handlers.length > 0) {
|
||||
for ( j = 0; j < handlers.length; j++) {
|
||||
handlers[j].apply(that, args);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
that.trigger = publishEvent;
|
||||
|
||||
that.getWidth = function() {
|
||||
return calculatedWidth;
|
||||
};
|
||||
|
||||
that.getHeight = function() {
|
||||
return calculatedHeight;
|
||||
};
|
||||
|
||||
that.setWidth = function(width) {
|
||||
calculatedWidth = width;
|
||||
};
|
||||
|
||||
that.setHeight = function(height) {
|
||||
calculatedHeight = height;
|
||||
};
|
||||
|
||||
that.getRealWidth = function() {
|
||||
return width;
|
||||
};
|
||||
|
||||
that.getRealHeight = function() {
|
||||
return height;
|
||||
};
|
||||
|
||||
that.setInputStream = function(stream) {
|
||||
_config = stream;
|
||||
baseUrl = _config.src;
|
||||
size = 1;
|
||||
loadImages();
|
||||
};
|
||||
|
||||
that.ended = function() {
|
||||
return ended;
|
||||
};
|
||||
|
||||
that.setAttribute = function() {};
|
||||
|
||||
that.getConfig = function() {
|
||||
return _config;
|
||||
};
|
||||
|
||||
that.pause = function() {
|
||||
paused = true;
|
||||
};
|
||||
|
||||
that.play = function() {
|
||||
paused = false;
|
||||
};
|
||||
|
||||
that.setCurrentTime = function(time) {
|
||||
frameIdx = time;
|
||||
};
|
||||
|
||||
that.addEventListener = function(event, f) {
|
||||
if (_eventNames.indexOf(event) !== -1) {
|
||||
if (!_eventHandlers[event]) {
|
||||
_eventHandlers[event] = [];
|
||||
}
|
||||
_eventHandlers[event].push(f);
|
||||
}
|
||||
};
|
||||
|
||||
that.setTopRight = function(topRight) {
|
||||
_topRight.x = topRight.x;
|
||||
_topRight.y = topRight.y;
|
||||
};
|
||||
|
||||
that.getTopRight = function() {
|
||||
return _topRight;
|
||||
};
|
||||
|
||||
that.setCanvasSize = function(size) {
|
||||
_canvasSize.x = size.x;
|
||||
_canvasSize.y = size.y;
|
||||
};
|
||||
|
||||
that.getCanvasSize = function() {
|
||||
return _canvasSize;
|
||||
};
|
||||
|
||||
that.getFrame = function() {
|
||||
if (!loaded){
|
||||
return null;
|
||||
}
|
||||
return frame;
|
||||
};
|
||||
|
||||
return that;
|
||||
};
|
||||
|
||||
return (InputStream);
|
||||
});
|
||||
@ -0,0 +1,13 @@
|
||||
var requirejs = require('requirejs'),
|
||||
path = require('path');
|
||||
|
||||
requirejs.config({
|
||||
"baseUrl" : path.resolve(__dirname, '..', 'src'),
|
||||
"paths" : {
|
||||
"typedefs" : "typedefs",
|
||||
"input_stream": "../lib/input_stream",
|
||||
"frame_grabber": "../lib/frame_grabber"
|
||||
},
|
||||
nodeRequire: require
|
||||
});
|
||||
module.exports = requirejs('quagga');
|
||||
@ -1,408 +0,0 @@
|
||||
/*
|
||||
* glMatrixAddon.js
|
||||
* Extension to the glMatrix library. The original glMatrix library
|
||||
* was created by Brandon Jones.
|
||||
*/
|
||||
|
||||
|
||||
mat4.xVec4 = function(mat, vec, dest){
|
||||
if(!dest) { dest = vec; }
|
||||
var x = vec[0], y = vec[1], z = vec[2], w = vec[3];
|
||||
|
||||
dest[0] = mat[0]*x + mat[1]*y + mat[2]*z + mat[3]*w;
|
||||
dest[1] = mat[4]*x + mat[5]*y + mat[6]*z + mat[7]*w;
|
||||
dest[2] = mat[8]*x + mat[9]*y + mat[10]*z + mat[11]*w;
|
||||
dest[3] = mat[12]*x + mat[13]*y + mat[14]*z + mat[15]*w;
|
||||
|
||||
return dest;
|
||||
};
|
||||
|
||||
mat3.scale = function(mat, scalar, dest){
|
||||
if(!dest || mat == dest) {
|
||||
mat[0] *= scalar;
|
||||
mat[1] *= scalar;
|
||||
mat[2] *= scalar;
|
||||
mat[3] *= scalar;
|
||||
mat[4] *= scalar;
|
||||
mat[5] *= scalar;
|
||||
mat[6] *= scalar;
|
||||
mat[7] *= scalar;
|
||||
mat[8] *= scalar;
|
||||
return mat;
|
||||
}
|
||||
dest = mat3.create();
|
||||
dest[0] = mat[0]*scalar;
|
||||
dest[1] = mat[1]*scalar;
|
||||
dest[2] = mat[2]*scalar;
|
||||
dest[3] = mat[3]*scalar;
|
||||
dest[4] = mat[4]*scalar;
|
||||
dest[5] = mat[5]*scalar;
|
||||
dest[6] = mat[6]*scalar;
|
||||
dest[7] = mat[7]*scalar;
|
||||
dest[8] = mat[8]*scalar;
|
||||
return dest;
|
||||
};
|
||||
|
||||
mat3.inverse = function(mat, dest){
|
||||
if(!dest) { dest = mat; }
|
||||
|
||||
var ha00 = mat[0], ha01 = mat[1], ha02 = mat[2];
|
||||
var ha10 = mat[3], ha11 = mat[4], ha12 = mat[5];
|
||||
var ha20 = mat[6], ha21 = mat[7], ha22 = mat[8];
|
||||
|
||||
var invDetA = 1/(ha00*ha11*ha22 + ha01*ha12*ha20 + ha02*ha10*ha21 - ha02*ha11*ha20 - ha01*ha10*ha22 - ha00*ha12*ha21);
|
||||
dest[0] = (ha11*ha22 - ha12*ha21)*invDetA;
|
||||
dest[1] = (ha02*ha21 - ha01*ha22)*invDetA;
|
||||
dest[2] = (ha01*ha12 - ha02*ha11)*invDetA;
|
||||
dest[3] = (ha12*ha20 - ha10*ha22)*invDetA;
|
||||
dest[4] = (ha00*ha22 - ha02*ha20)*invDetA;
|
||||
dest[5] = (ha02*ha10 - ha00*ha12)*invDetA;
|
||||
dest[6] = (ha10*ha21 - ha11*ha20)*invDetA;
|
||||
dest[7] = (ha01*ha20 - ha00*ha21)*invDetA;
|
||||
dest[8] = (ha00*ha11 - ha01*ha10)*invDetA;
|
||||
return dest;
|
||||
};
|
||||
|
||||
mat3.multiply = function(mat, mat2, dest) {
|
||||
if(!dest) { dest = mat; }
|
||||
|
||||
var ha00 = mat[0], ha01 = mat[1], ha02 = mat[2];
|
||||
var ha10 = mat[3], ha11 = mat[4], ha12 = mat[5];
|
||||
var ha20 = mat[6], ha21 = mat[7], ha22 = mat[8];
|
||||
|
||||
var hb00 = mat2[0], hb01 = mat2[1], hb02 = mat2[2];
|
||||
var hb10 = mat2[3], hb11 = mat2[4], hb12 = mat2[5];
|
||||
var hb20 = mat2[6], hb21 = mat2[7], hb22 = mat2[8];
|
||||
|
||||
dest[0] = ha00*hb00 + ha01*hb10 + ha02*hb20;
|
||||
dest[1] = ha00*hb01 + ha01*hb11 + ha02*hb21;
|
||||
dest[2] = ha00*hb02 + ha01*hb12 + ha02*hb22;
|
||||
|
||||
dest[3] = ha10*hb00 + ha11*hb10 + ha12*hb20;
|
||||
dest[4] = ha10*hb01 + ha11*hb11 + ha12*hb21;
|
||||
dest[5] = ha10*hb02 + ha11*hb12 + ha12*hb22;
|
||||
|
||||
dest[6] = ha20*hb00 + ha21*hb10 + ha22*hb20;
|
||||
dest[7] = ha20*hb01 + ha21*hb11 + ha22*hb21;
|
||||
dest[8] = ha20*hb02 + ha21*hb12 + ha22*hb22;
|
||||
return dest;
|
||||
};
|
||||
|
||||
mat3.xVec3 = function(mat, vec, dest){
|
||||
if(!dest) { dest = vec; }
|
||||
var x = vec[0], y = vec[1], z = vec[2];
|
||||
|
||||
dest[0] = mat[0]*x + mat[1]*y + mat[2]*z;
|
||||
dest[1] = mat[3]*x + mat[4]*y + mat[5]*z;
|
||||
dest[2] = mat[6]*x + mat[7]*y + mat[8]*z;
|
||||
|
||||
return dest;
|
||||
};
|
||||
|
||||
var vec4={};
|
||||
|
||||
vec4.create = function(vec){
|
||||
var dest;
|
||||
|
||||
if(vec) {
|
||||
dest = new glMatrixArrayType(4);
|
||||
dest[0] = vec[0];
|
||||
dest[1] = vec[1];
|
||||
dest[2] = vec[2];
|
||||
dest[3] = vec[3];
|
||||
} else {
|
||||
if(glMatrixArrayType === Array)
|
||||
dest = new glMatrixArrayType([0,0,0,0]);
|
||||
else
|
||||
dest = new glMatrixArrayType(4);
|
||||
}
|
||||
|
||||
return dest;
|
||||
};
|
||||
|
||||
vec4.project = function(vec, dest){
|
||||
if(!dest) { dest = vec; }
|
||||
|
||||
dest[0] = vec[0]/vec[3];
|
||||
dest[1] = vec[1]/vec[3];
|
||||
dest[2] = vec[2]/vec[3];
|
||||
return dest;
|
||||
};
|
||||
|
||||
vec4.scale = function(vec, val, dest){
|
||||
if(!dest || vec == dest) {
|
||||
vec[0] *= val;
|
||||
vec[1] *= val;
|
||||
vec[2] *= val;
|
||||
vec[4] *= val;
|
||||
return vec;
|
||||
}
|
||||
|
||||
dest[0] = vec[0]*val;
|
||||
dest[1] = vec[1]*val;
|
||||
dest[2] = vec[2]*val;
|
||||
dest[3] = vec[3]*val;
|
||||
return dest;
|
||||
};
|
||||
|
||||
vec4.xMat4 = function(vec, mat, dest){
|
||||
if(!dest) { dest = vec; }
|
||||
|
||||
var x = vec[0], y = vec[1], z = vec[2], w = vec[3];
|
||||
|
||||
dest[0] = mat[0]*x + mat[4]*y + mat[8]*z + mat[12]*w;
|
||||
dest[1] = mat[1]*x + mat[5]*y + mat[9]*z + mat[13]*w;
|
||||
dest[2] = mat[2]*x + mat[6]*y + mat[10]*z + mat[14]*w;
|
||||
dest[3] = mat[3]*x + mat[7]*y + mat[11]*z + mat[15]*w;
|
||||
|
||||
return dest;
|
||||
};
|
||||
|
||||
|
||||
var mat2 = {};
|
||||
|
||||
mat2.create = function(mat){
|
||||
var dest;
|
||||
|
||||
if(mat) {
|
||||
dest = new glMatrixArrayType(4);
|
||||
dest[0] = mat[0];
|
||||
dest[1] = mat[1];
|
||||
dest[2] = mat[2];
|
||||
dest[3] = mat[3];
|
||||
} else {
|
||||
if(glMatrixArrayType === Array)
|
||||
dest = new glMatrixArrayType([0,0,0,0]);
|
||||
else
|
||||
dest = new glMatrixArrayType(4);
|
||||
}
|
||||
|
||||
return dest;
|
||||
};
|
||||
|
||||
mat2.xVec2 = function(mat, vec, dest){
|
||||
if(!dest) { dest = vec; }
|
||||
var x = vec[0], y = vec[1];
|
||||
|
||||
dest[0] = mat[0]*x + mat[1]*y;
|
||||
dest[1] = mat[2]*x + mat[3]*y;
|
||||
|
||||
return dest;
|
||||
};
|
||||
|
||||
mat2.scale = function(mat, scale, dest){
|
||||
if(!dest || mat == dest) {
|
||||
mat[0] *= scale;
|
||||
mat[1] *= scale;
|
||||
mat[2] *= scale;
|
||||
mat[3] *= scale;
|
||||
return mat;
|
||||
}
|
||||
|
||||
dest[0] = mat[0]*scale;
|
||||
dest[1] = mat[1]*scale;
|
||||
dest[2] = mat[2]*scale;
|
||||
dest[3] = mat[3]*scale;
|
||||
return dest;
|
||||
};
|
||||
|
||||
mat2.determinant = function(mat){
|
||||
return mat[0]*mat[3] - mat[1]*mat[2];
|
||||
};
|
||||
|
||||
mat2.inverse = function(mat){
|
||||
var scale = 1/(mat2.determinant(mat));
|
||||
var a = mat[3]*scale,
|
||||
b = -mat[1]*scale,
|
||||
c = -mat[2]*scale,
|
||||
d = mat[0];
|
||||
mat[0] = a;
|
||||
mat[1] = b;
|
||||
mat[2] = c;
|
||||
mat[3] = d;
|
||||
return mat;
|
||||
};
|
||||
|
||||
var vec2 = {};
|
||||
vec2.create = function(vec){
|
||||
var dest;
|
||||
|
||||
if(vec) {
|
||||
dest = new glMatrixArrayType(2);
|
||||
dest[0] = vec[0];
|
||||
dest[1] = vec[1];
|
||||
} else {
|
||||
if(glMatrixArrayType === Array)
|
||||
dest = new glMatrixArrayType([0,0]);
|
||||
else
|
||||
dest = new glMatrixArrayType(2);
|
||||
}
|
||||
|
||||
return dest;
|
||||
};
|
||||
|
||||
vec2.subtract = function(vec, vec2, dest) {
|
||||
if(!dest || vec == dest) {
|
||||
vec[0] -= vec2[0];
|
||||
vec[1] -= vec2[1];
|
||||
return vec;
|
||||
}
|
||||
|
||||
dest[0] = vec[0] - vec2[0];
|
||||
dest[1] = vec[1] - vec2[1];
|
||||
return dest;
|
||||
};
|
||||
|
||||
vec2.add = function(vec, vec2, dest) {
|
||||
if(!dest || vec == dest) {
|
||||
vec[0] += vec2[0];
|
||||
vec[1] += vec2[1];
|
||||
return vec;
|
||||
}
|
||||
|
||||
dest[0] = vec[0] + vec2[0];
|
||||
dest[1] = vec[1] + vec2[1];
|
||||
return dest;
|
||||
};
|
||||
|
||||
vec2.scale = function(vec, val, dest) {
|
||||
if(!dest || vec == dest) {
|
||||
vec[0] *= val;
|
||||
vec[1] *= val;
|
||||
return vec;
|
||||
}
|
||||
|
||||
dest[0] = vec[0]*val;
|
||||
dest[1] = vec[1]*val;
|
||||
return dest;
|
||||
};
|
||||
|
||||
vec2.normalize = function(vec, dest) {
|
||||
if(!dest) { dest = vec; }
|
||||
|
||||
var x = vec[0], y = vec[1];
|
||||
var len = Math.sqrt(x*x + y*y);
|
||||
|
||||
if (!len) {
|
||||
dest[0] = 0;
|
||||
dest[1] = 0;
|
||||
return dest;
|
||||
} else if (len == 1) {
|
||||
dest[0] = x;
|
||||
dest[1] = y;
|
||||
return dest;
|
||||
}
|
||||
|
||||
len = 1 / len;
|
||||
dest[0] = x*len;
|
||||
dest[1] = y*len;
|
||||
return dest;
|
||||
};
|
||||
|
||||
vec2.dot = function(vec, vec2){
|
||||
return vec[0]*vec2[0] + vec[1]*vec2[1];
|
||||
};
|
||||
|
||||
vec2.multiply = function(vec, vec2, dest){
|
||||
if(!dest) { dest = vec; }
|
||||
|
||||
dest[0] = vec[0]*vec2[0];
|
||||
dest[1] = vec[1]*vec2[1];
|
||||
return dest;
|
||||
};
|
||||
|
||||
/**
|
||||
* @param vec vec2 to be unprojected [x,y] -> [x,y,1]
|
||||
* @returns vec3 unprojected vector
|
||||
*/
|
||||
vec2.unproject = function(vec){
|
||||
return vec3.create([vec[0], vec[1], 1]);
|
||||
};
|
||||
|
||||
vec2.length = function(vec){
|
||||
return Math.sqrt(vec[0]*vec[0] + vec[1]*vec[1]);
|
||||
};
|
||||
|
||||
vec2.perspectiveProject = function(vec){
|
||||
var result = vec2.create(vec);
|
||||
return vec2.scale(result, 1/vec[2]);
|
||||
};
|
||||
|
||||
/**
|
||||
* @param vec vec3 to be projected [x,y,z] -> [x/z,y/z]
|
||||
* @returns vec2 projected vector
|
||||
*/
|
||||
vec3.project = function(vec){
|
||||
return vec2.scale(vec2.create(vec), 1/vec[2]);
|
||||
};
|
||||
|
||||
var vec6 = {};
|
||||
vec6.scale = function(vec, val, dest){
|
||||
if(!dest || vec == dest) {
|
||||
vec[0] *= val;
|
||||
vec[1] *= val;
|
||||
vec[2] *= val;
|
||||
vec[3] *= val;
|
||||
vec[4] *= val;
|
||||
vec[5] *= val;
|
||||
return vec;
|
||||
}
|
||||
|
||||
dest[0] = vec[0]*val;
|
||||
dest[1] = vec[1]*val;
|
||||
dest[2] = vec[2]*val;
|
||||
dest[3] = vec[3]*val;
|
||||
dest[4] = vec[4]*val;
|
||||
dest[5] = vec[5]*val;
|
||||
return dest;
|
||||
};
|
||||
|
||||
vec6.subtract = function(vec, vec2, dest){
|
||||
if(!dest || vec == dest) {
|
||||
vec[0] -= vec2[0];
|
||||
vec[1] -= vec2[1];
|
||||
vec[2] -= vec2[2];
|
||||
vec[3] -= vec2[3];
|
||||
vec[4] -= vec2[4];
|
||||
vec[5] -= vec2[5];
|
||||
return vec;
|
||||
}
|
||||
|
||||
dest[0] = vec[0] - vec2[0];
|
||||
dest[1] = vec[1] - vec2[1];
|
||||
dest[2] = vec[2] - vec2[2];
|
||||
dest[3] = vec[3] - vec2[3];
|
||||
dest[4] = vec[4] - vec2[4];
|
||||
dest[5] = vec[5] - vec2[5];
|
||||
return dest;
|
||||
};
|
||||
|
||||
vec6.dot = function(vec, vec2){
|
||||
return vec[0]*vec2[0] + vec[1]*vec2[1] + vec[2]*vec2[2] + vec[3]*vec2[3] + vec[4]*vec2[4] + vec[5]*vec2[5];
|
||||
};
|
||||
|
||||
var mat6 = {};
|
||||
mat6.xVec6 = function(mat, vec, dest){
|
||||
if(!dest) { dest = vec; }
|
||||
var x = vec[0], y = vec[1], z = vec[2], u = vec[3], w = vec[4], v = vec[5];
|
||||
|
||||
dest[0] = mat[0]*x + mat[1]*y + mat[2]*z + mat[3]*u + mat[4]*w + mat[5]*v;
|
||||
dest[1] = mat[6]*x + mat[7]*y + mat[8]*z + mat[9]*u + mat[10]*w + mat[11]*v;
|
||||
dest[2] = mat[12]*x + mat[13]*y + mat[14]*z + mat[15]*u + mat[16]*w + mat[17]*v;
|
||||
dest[3] = mat[18]*x + mat[19]*y + mat[20]*z + mat[21]*u + mat[22]*w + mat[23]*v;
|
||||
dest[4] = mat[24]*x + mat[25]*y + mat[26]*z + mat[27]*u + mat[28]*w + mat[29]*v;
|
||||
dest[5] = mat[30]*x + mat[31]*y + mat[32]*z + mat[33]*u + mat[34]*w + mat[35]*v;
|
||||
|
||||
return dest;
|
||||
};
|
||||
|
||||
mat3.xVec3 = function(mat, vec, dest){
|
||||
if(!dest) { dest = vec; }
|
||||
var x = vec[0], y = vec[1], z = vec[2];
|
||||
|
||||
dest[0] = mat[0]*x + mat[1]*y + mat[2]*z;
|
||||
dest[1] = mat[3]*x + mat[4]*y + mat[5]*z;
|
||||
dest[2] = mat[6]*x + mat[7]*y + mat[8]*z;
|
||||
|
||||
return dest;
|
||||
};
|
||||
@ -1,410 +0,0 @@
|
||||
/**
|
||||
* almond 0.2.6 Copyright (c) 2011-2012, The Dojo Foundation All Rights Reserved.
|
||||
* Available via the MIT or new BSD license.
|
||||
* see: http://github.com/jrburke/almond for details
|
||||
*/
|
||||
//Going sloppy to avoid 'use strict' string cost, but strict practices should
|
||||
//be followed.
|
||||
/*jslint sloppy: true */
|
||||
/*global setTimeout: false */
|
||||
|
||||
var requirejs, require, define;
|
||||
(function (undef) {
|
||||
var main, req, makeMap, handlers,
|
||||
defined = {},
|
||||
waiting = {},
|
||||
config = {},
|
||||
defining = {},
|
||||
hasOwn = Object.prototype.hasOwnProperty,
|
||||
aps = [].slice;
|
||||
|
||||
function hasProp(obj, prop) {
|
||||
return hasOwn.call(obj, prop);
|
||||
}
|
||||
|
||||
/**
|
||||
* Given a relative module name, like ./something, normalize it to
|
||||
* a real name that can be mapped to a path.
|
||||
* @param {String} name the relative name
|
||||
* @param {String} baseName a real name that the name arg is relative
|
||||
* to.
|
||||
* @returns {String} normalized name
|
||||
*/
|
||||
function normalize(name, baseName) {
|
||||
var nameParts, nameSegment, mapValue, foundMap,
|
||||
foundI, foundStarMap, starI, i, j, part,
|
||||
baseParts = baseName && baseName.split("/"),
|
||||
map = config.map,
|
||||
starMap = (map && map['*']) || {};
|
||||
|
||||
//Adjust any relative paths.
|
||||
if (name && name.charAt(0) === ".") {
|
||||
//If have a base name, try to normalize against it,
|
||||
//otherwise, assume it is a top-level require that will
|
||||
//be relative to baseUrl in the end.
|
||||
if (baseName) {
|
||||
//Convert baseName to array, and lop off the last part,
|
||||
//so that . matches that "directory" and not name of the baseName's
|
||||
//module. For instance, baseName of "one/two/three", maps to
|
||||
//"one/two/three.js", but we want the directory, "one/two" for
|
||||
//this normalization.
|
||||
baseParts = baseParts.slice(0, baseParts.length - 1);
|
||||
|
||||
name = baseParts.concat(name.split("/"));
|
||||
|
||||
//start trimDots
|
||||
for (i = 0; i < name.length; i += 1) {
|
||||
part = name[i];
|
||||
if (part === ".") {
|
||||
name.splice(i, 1);
|
||||
i -= 1;
|
||||
} else if (part === "..") {
|
||||
if (i === 1 && (name[2] === '..' || name[0] === '..')) {
|
||||
//End of the line. Keep at least one non-dot
|
||||
//path segment at the front so it can be mapped
|
||||
//correctly to disk. Otherwise, there is likely
|
||||
//no path mapping for a path starting with '..'.
|
||||
//This can still fail, but catches the most reasonable
|
||||
//uses of ..
|
||||
break;
|
||||
} else if (i > 0) {
|
||||
name.splice(i - 1, 2);
|
||||
i -= 2;
|
||||
}
|
||||
}
|
||||
}
|
||||
//end trimDots
|
||||
|
||||
name = name.join("/");
|
||||
} else if (name.indexOf('./') === 0) {
|
||||
// No baseName, so this is ID is resolved relative
|
||||
// to baseUrl, pull off the leading dot.
|
||||
name = name.substring(2);
|
||||
}
|
||||
}
|
||||
|
||||
//Apply map config if available.
|
||||
if ((baseParts || starMap) && map) {
|
||||
nameParts = name.split('/');
|
||||
|
||||
for (i = nameParts.length; i > 0; i -= 1) {
|
||||
nameSegment = nameParts.slice(0, i).join("/");
|
||||
|
||||
if (baseParts) {
|
||||
//Find the longest baseName segment match in the config.
|
||||
//So, do joins on the biggest to smallest lengths of baseParts.
|
||||
for (j = baseParts.length; j > 0; j -= 1) {
|
||||
mapValue = map[baseParts.slice(0, j).join('/')];
|
||||
|
||||
//baseName segment has config, find if it has one for
|
||||
//this name.
|
||||
if (mapValue) {
|
||||
mapValue = mapValue[nameSegment];
|
||||
if (mapValue) {
|
||||
//Match, update name to the new value.
|
||||
foundMap = mapValue;
|
||||
foundI = i;
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (foundMap) {
|
||||
break;
|
||||
}
|
||||
|
||||
//Check for a star map match, but just hold on to it,
|
||||
//if there is a shorter segment match later in a matching
|
||||
//config, then favor over this star map.
|
||||
if (!foundStarMap && starMap && starMap[nameSegment]) {
|
||||
foundStarMap = starMap[nameSegment];
|
||||
starI = i;
|
||||
}
|
||||
}
|
||||
|
||||
if (!foundMap && foundStarMap) {
|
||||
foundMap = foundStarMap;
|
||||
foundI = starI;
|
||||
}
|
||||
|
||||
if (foundMap) {
|
||||
nameParts.splice(0, foundI, foundMap);
|
||||
name = nameParts.join('/');
|
||||
}
|
||||
}
|
||||
|
||||
return name;
|
||||
}
|
||||
|
||||
function makeRequire(relName, forceSync) {
|
||||
return function () {
|
||||
//A version of a require function that passes a moduleName
|
||||
//value for items that may need to
|
||||
//look up paths relative to the moduleName
|
||||
return req.apply(undef, aps.call(arguments, 0).concat([relName, forceSync]));
|
||||
};
|
||||
}
|
||||
|
||||
function makeNormalize(relName) {
|
||||
return function (name) {
|
||||
return normalize(name, relName);
|
||||
};
|
||||
}
|
||||
|
||||
function makeLoad(depName) {
|
||||
return function (value) {
|
||||
defined[depName] = value;
|
||||
};
|
||||
}
|
||||
|
||||
function callDep(name) {
|
||||
if (hasProp(waiting, name)) {
|
||||
var args = waiting[name];
|
||||
delete waiting[name];
|
||||
defining[name] = true;
|
||||
main.apply(undef, args);
|
||||
}
|
||||
|
||||
if (!hasProp(defined, name) && !hasProp(defining, name)) {
|
||||
throw new Error('No ' + name);
|
||||
}
|
||||
return defined[name];
|
||||
}
|
||||
|
||||
//Turns a plugin!resource to [plugin, resource]
|
||||
//with the plugin being undefined if the name
|
||||
//did not have a plugin prefix.
|
||||
function splitPrefix(name) {
|
||||
var prefix,
|
||||
index = name ? name.indexOf('!') : -1;
|
||||
if (index > -1) {
|
||||
prefix = name.substring(0, index);
|
||||
name = name.substring(index + 1, name.length);
|
||||
}
|
||||
return [prefix, name];
|
||||
}
|
||||
|
||||
/**
|
||||
* Makes a name map, normalizing the name, and using a plugin
|
||||
* for normalization if necessary. Grabs a ref to plugin
|
||||
* too, as an optimization.
|
||||
*/
|
||||
makeMap = function (name, relName) {
|
||||
var plugin,
|
||||
parts = splitPrefix(name),
|
||||
prefix = parts[0];
|
||||
|
||||
name = parts[1];
|
||||
|
||||
if (prefix) {
|
||||
prefix = normalize(prefix, relName);
|
||||
plugin = callDep(prefix);
|
||||
}
|
||||
|
||||
//Normalize according
|
||||
if (prefix) {
|
||||
if (plugin && plugin.normalize) {
|
||||
name = plugin.normalize(name, makeNormalize(relName));
|
||||
} else {
|
||||
name = normalize(name, relName);
|
||||
}
|
||||
} else {
|
||||
name = normalize(name, relName);
|
||||
parts = splitPrefix(name);
|
||||
prefix = parts[0];
|
||||
name = parts[1];
|
||||
if (prefix) {
|
||||
plugin = callDep(prefix);
|
||||
}
|
||||
}
|
||||
|
||||
//Using ridiculous property names for space reasons
|
||||
return {
|
||||
f: prefix ? prefix + '!' + name : name, //fullName
|
||||
n: name,
|
||||
pr: prefix,
|
||||
p: plugin
|
||||
};
|
||||
};
|
||||
|
||||
function makeConfig(name) {
|
||||
return function () {
|
||||
return (config && config.config && config.config[name]) || {};
|
||||
};
|
||||
}
|
||||
|
||||
handlers = {
|
||||
require: function (name) {
|
||||
return makeRequire(name);
|
||||
},
|
||||
exports: function (name) {
|
||||
var e = defined[name];
|
||||
if (typeof e !== 'undefined') {
|
||||
return e;
|
||||
} else {
|
||||
return (defined[name] = {});
|
||||
}
|
||||
},
|
||||
module: function (name) {
|
||||
return {
|
||||
id: name,
|
||||
uri: '',
|
||||
exports: defined[name],
|
||||
config: makeConfig(name)
|
||||
};
|
||||
}
|
||||
};
|
||||
|
||||
main = function (name, deps, callback, relName) {
|
||||
var cjsModule, depName, ret, map, i,
|
||||
args = [],
|
||||
usingExports;
|
||||
|
||||
//Use name if no relName
|
||||
relName = relName || name;
|
||||
|
||||
//Call the callback to define the module, if necessary.
|
||||
if (typeof callback === 'function') {
|
||||
|
||||
//Pull out the defined dependencies and pass the ordered
|
||||
//values to the callback.
|
||||
//Default to [require, exports, module] if no deps
|
||||
deps = !deps.length && callback.length ? ['require', 'exports', 'module'] : deps;
|
||||
for (i = 0; i < deps.length; i += 1) {
|
||||
map = makeMap(deps[i], relName);
|
||||
depName = map.f;
|
||||
|
||||
//Fast path CommonJS standard dependencies.
|
||||
if (depName === "require") {
|
||||
args[i] = handlers.require(name);
|
||||
} else if (depName === "exports") {
|
||||
//CommonJS module spec 1.1
|
||||
args[i] = handlers.exports(name);
|
||||
usingExports = true;
|
||||
} else if (depName === "module") {
|
||||
//CommonJS module spec 1.1
|
||||
cjsModule = args[i] = handlers.module(name);
|
||||
} else if (hasProp(defined, depName) ||
|
||||
hasProp(waiting, depName) ||
|
||||
hasProp(defining, depName)) {
|
||||
args[i] = callDep(depName);
|
||||
} else if (map.p) {
|
||||
map.p.load(map.n, makeRequire(relName, true), makeLoad(depName), {});
|
||||
args[i] = defined[depName];
|
||||
} else {
|
||||
throw new Error(name + ' missing ' + depName);
|
||||
}
|
||||
}
|
||||
|
||||
ret = callback.apply(defined[name], args);
|
||||
|
||||
if (name) {
|
||||
//If setting exports via "module" is in play,
|
||||
//favor that over return value and exports. After that,
|
||||
//favor a non-undefined return value over exports use.
|
||||
if (cjsModule && cjsModule.exports !== undef &&
|
||||
cjsModule.exports !== defined[name]) {
|
||||
defined[name] = cjsModule.exports;
|
||||
} else if (ret !== undef || !usingExports) {
|
||||
//Use the return value from the function.
|
||||
defined[name] = ret;
|
||||
}
|
||||
}
|
||||
} else if (name) {
|
||||
//May just be an object definition for the module. Only
|
||||
//worry about defining if have a module name.
|
||||
defined[name] = callback;
|
||||
}
|
||||
};
|
||||
|
||||
requirejs = require = req = function (deps, callback, relName, forceSync, alt) {
|
||||
if (typeof deps === "string") {
|
||||
if (handlers[deps]) {
|
||||
//callback in this case is really relName
|
||||
return handlers[deps](callback);
|
||||
}
|
||||
//Just return the module wanted. In this scenario, the
|
||||
//deps arg is the module name, and second arg (if passed)
|
||||
//is just the relName.
|
||||
//Normalize module name, if it contains . or ..
|
||||
return callDep(makeMap(deps, callback).f);
|
||||
} else if (!deps.splice) {
|
||||
//deps is a config object, not an array.
|
||||
config = deps;
|
||||
if (callback.splice) {
|
||||
//callback is an array, which means it is a dependency list.
|
||||
//Adjust args if there are dependencies
|
||||
deps = callback;
|
||||
callback = relName;
|
||||
relName = null;
|
||||
} else {
|
||||
deps = undef;
|
||||
}
|
||||
}
|
||||
|
||||
//Support require(['a'])
|
||||
callback = callback || function () {};
|
||||
|
||||
//If relName is a function, it is an errback handler,
|
||||
//so remove it.
|
||||
if (typeof relName === 'function') {
|
||||
relName = forceSync;
|
||||
forceSync = alt;
|
||||
}
|
||||
|
||||
//Simulate async callback;
|
||||
if (forceSync) {
|
||||
main(undef, deps, callback, relName);
|
||||
} else {
|
||||
//Using a non-zero value because of concern for what old browsers
|
||||
//do, and latest browsers "upgrade" to 4 if lower value is used:
|
||||
//http://www.whatwg.org/specs/web-apps/current-work/multipage/timers.html#dom-windowtimers-settimeout:
|
||||
//If want a value immediately, use require('id') instead -- something
|
||||
//that works in almond on the global level, but not guaranteed and
|
||||
//unlikely to work in other AMD implementations.
|
||||
setTimeout(function () {
|
||||
main(undef, deps, callback, relName);
|
||||
}, 4);
|
||||
}
|
||||
|
||||
return req;
|
||||
};
|
||||
|
||||
/**
|
||||
* Just drops the config on the floor, but returns req in case
|
||||
* the config return value is used.
|
||||
*/
|
||||
req.config = function (cfg) {
|
||||
config = cfg;
|
||||
if (config.deps) {
|
||||
req(config.deps, config.callback);
|
||||
}
|
||||
return req;
|
||||
};
|
||||
|
||||
/**
|
||||
* Expose module registry for debugging and tooling
|
||||
*/
|
||||
requirejs._defined = defined;
|
||||
|
||||
define = function (name, deps, callback) {
|
||||
|
||||
//This module may not have dependencies
|
||||
if (!deps.splice) {
|
||||
//deps is not an array, so probably means
|
||||
//an object literal or factory function for
|
||||
//the value. Adjust args.
|
||||
callback = deps;
|
||||
deps = [];
|
||||
}
|
||||
|
||||
if (!hasProp(defined, name) && !hasProp(waiting, name)) {
|
||||
waiting[name] = [name, deps, callback];
|
||||
}
|
||||
};
|
||||
|
||||
define.amd = {
|
||||
jQuery: true
|
||||
};
|
||||
}());
|
||||
@ -1,121 +0,0 @@
|
||||
/*
|
||||
* http://www.quirksmode.org/js/detect.html
|
||||
*/
|
||||
|
||||
var BrowserDetect = {
|
||||
init: function () {
|
||||
this.browser = this.searchString(this.dataBrowser) || "An unknown browser";
|
||||
this.version = this.searchVersion(navigator.userAgent)
|
||||
|| this.searchVersion(navigator.appVersion)
|
||||
|| "an unknown version";
|
||||
this.OS = this.searchString(this.dataOS) || "an unknown OS";
|
||||
},
|
||||
searchString: function (data) {
|
||||
for (var i=0;i<data.length;i++) {
|
||||
var dataString = data[i].string;
|
||||
var dataProp = data[i].prop;
|
||||
this.versionSearchString = data[i].versionSearch || data[i].identity;
|
||||
if (dataString) {
|
||||
if (dataString.indexOf(data[i].subString) != -1)
|
||||
return data[i].identity;
|
||||
}
|
||||
else if (dataProp)
|
||||
return data[i].identity;
|
||||
}
|
||||
},
|
||||
searchVersion: function (dataString) {
|
||||
var index = dataString.indexOf(this.versionSearchString);
|
||||
if (index == -1) return;
|
||||
return parseFloat(dataString.substring(index+this.versionSearchString.length+1));
|
||||
},
|
||||
dataBrowser: [
|
||||
{
|
||||
string: navigator.userAgent,
|
||||
subString: "Chrome",
|
||||
identity: "Chrome"
|
||||
},
|
||||
{ string: navigator.userAgent,
|
||||
subString: "OmniWeb",
|
||||
versionSearch: "OmniWeb/",
|
||||
identity: "OmniWeb"
|
||||
},
|
||||
{
|
||||
string: navigator.vendor,
|
||||
subString: "Apple",
|
||||
identity: "Safari",
|
||||
versionSearch: "Version"
|
||||
},
|
||||
{
|
||||
prop: window.opera,
|
||||
identity: "Opera",
|
||||
versionSearch: "Version"
|
||||
},
|
||||
{
|
||||
string: navigator.vendor,
|
||||
subString: "iCab",
|
||||
identity: "iCab"
|
||||
},
|
||||
{
|
||||
string: navigator.vendor,
|
||||
subString: "KDE",
|
||||
identity: "Konqueror"
|
||||
},
|
||||
{
|
||||
string: navigator.userAgent,
|
||||
subString: "Firefox",
|
||||
identity: "Firefox"
|
||||
},
|
||||
{
|
||||
string: navigator.vendor,
|
||||
subString: "Camino",
|
||||
identity: "Camino"
|
||||
},
|
||||
{ // for newer Netscapes (6+)
|
||||
string: navigator.userAgent,
|
||||
subString: "Netscape",
|
||||
identity: "Netscape"
|
||||
},
|
||||
{
|
||||
string: navigator.userAgent,
|
||||
subString: "MSIE",
|
||||
identity: "Explorer",
|
||||
versionSearch: "MSIE"
|
||||
},
|
||||
{
|
||||
string: navigator.userAgent,
|
||||
subString: "Gecko",
|
||||
identity: "Mozilla",
|
||||
versionSearch: "rv"
|
||||
},
|
||||
{ // for older Netscapes (4-)
|
||||
string: navigator.userAgent,
|
||||
subString: "Mozilla",
|
||||
identity: "Netscape",
|
||||
versionSearch: "Mozilla"
|
||||
}
|
||||
],
|
||||
dataOS : [
|
||||
{
|
||||
string: navigator.platform,
|
||||
subString: "Win",
|
||||
identity: "Windows"
|
||||
},
|
||||
{
|
||||
string: navigator.platform,
|
||||
subString: "Mac",
|
||||
identity: "Mac"
|
||||
},
|
||||
{
|
||||
string: navigator.userAgent,
|
||||
subString: "iPhone",
|
||||
identity: "iPhone/iPod"
|
||||
},
|
||||
{
|
||||
string: navigator.platform,
|
||||
subString: "Linux",
|
||||
identity: "Linux"
|
||||
}
|
||||
]
|
||||
|
||||
};
|
||||
BrowserDetect.init();
|
||||
File diff suppressed because it is too large
Load Diff
File diff suppressed because one or more lines are too long
File diff suppressed because it is too large
Load Diff
Loading…
Reference in New Issue