diff options
Diffstat (limited to 'addons/web_diagram/static/src/js/vec2.js')
| -rw-r--r-- | addons/web_diagram/static/src/js/vec2.js | 358 |
1 files changed, 358 insertions, 0 deletions
diff --git a/addons/web_diagram/static/src/js/vec2.js b/addons/web_diagram/static/src/js/vec2.js new file mode 100644 index 00000000000..28790008be3 --- /dev/null +++ b/addons/web_diagram/static/src/js/vec2.js @@ -0,0 +1,358 @@ + +(function(window){ + + // A Javascript 2D vector library + // conventions : + // method that returns a float value do not modify the vector + // method that implement operators return a new vector with the modifications without + // modifying the calling vector or the parameters. + // + // v3 = v1.add(v2); // v3 is set to v1 + v2, v1, v2 are not modified + // + // methods that take a single vector as a parameter are usually also available with + // q '_xy' suffix. Those method takes two floats representing the x,y coordinates of + // the vector parameter and allow you to avoid to needlessly create a vector object : + // + // v2 = v1.add(new Vec2(3,4)); + // v2 = v1.add_xy(3,4); //equivalent to previous line + // + // angles are in radians by default but method that takes angle as parameters + // or return angle values usually have a variant with a '_deg' suffix that works in degrees + // + + // The 2D vector object + function Vec2(x,y){ + this.x = x; + this.y = y; + } + + window.Vec2 = Vec2; + + // Multiply a number expressed in radiant by rad2deg to convert it in degrees + var rad2deg = 57.29577951308232; + // Multiply a number expressed in degrees by deg2rad to convert it to radiant + var deg2rad = 0.017453292519943295; + // The numerical precision used to compare vector equality + var epsilon = 0.0000001; + + // This static method creates a new vector from polar coordinates with the angle expressed + // in degrees + Vec2.new_polar_deg = function(len,angle){ + var v = new Vec2(len,0); + return v.rotate_deg(angle); + }; + // This static method creates a new vector from polar coordinates with the angle expressed in + // radians + Vec2.new_polar = function(len,angle){ + var v = new Vec2(len,0); + v.rotate(angle); + return v; + }; + // returns the length or modulus or magnitude of the vector + Vec2.prototype.len = function(){ + return Math.sqrt(this.x*this.x + this.y*this.y); + }; + // returns the squared length of the vector, this method is much faster than len() + Vec2.prototype.len_sq = function(){ + return this.x*this.x + this.y*this.y; + }; + // return the distance between this vector and the vector v + Vec2.prototype.dist = function(v){ + var dx = this.x - v.x; + var dy = this.y - v.y; + return Math.sqrt(dx*dx + dy*dy); + }; + // return the distance between this vector and the vector of coordinates (x,y) + Vec2.prototype.dist_xy = function(x,y){ + var dx = this.x - x; + var dy = this.y - y; + return Math.sqrt(dx*dx + dy*dy); + }; + // return the squared distance between this vector and the vector and the vector v + Vec2.prototype.dist_sq = function(v){ + var dx = this.x - v.x; + var dy = this.y - v.y; + return dx*dx + dy*dy; + }; + // return the squared distance between this vector and the vector of coordinates (x,y) + Vec2.prototype.dist_sq_xy = function(x,y){ + var dx = this.x - x; + var dy = this.y - y; + return dx*dx + dy*dy; + }; + // return the dot product between this vector and the vector v + Vec2.prototype.dot = function(v){ + return this.x*v.x + this.y*v.y; + }; + // return the dot product between this vector and the vector of coordinate (x,y) + Vec2.prototype.dot_xy = function(x,y){ + return this.x*x + this.y*y; + }; + // return a new vector with the same coordinates as this + Vec2.prototype.clone = function(){ + return new Vec2(this.x,this.y); + }; + // return the sum of this and vector v as a new vector + Vec2.prototype.add = function(v){ + return new Vec2(this.x+v.x,this.y+v.y); + }; + // return the sum of this and vector (x,y) as a new vector + Vec2.prototype.add_xy = function(x,y){ + return new Vec2(this.x+x,this.y+y); + }; + // returns (this - v) as a new vector where v is a vector and - is the vector subtraction + Vec2.prototype.sub = function(v){ + return new Vec2(this.x-v.x,this.y-v.y); + }; + // returns (this - (x,y)) as a new vector where - is vector subtraction + Vec2.prototype.sub_xy = function(x,y){ + return new Vec2(this.x-x,this.y-y); + }; + // return (this * v) as a new vector where v is a vector and * is the by component product + Vec2.prototype.mult = function(v){ + return new Vec2(this.x*v.x,this.y*v.y); + }; + // return (this * (x,y)) as a new vector where * is the by component product + Vec2.prototype.mult_xy = function(x,y){ + return new Vec2(this.x*x,this.y*y); + }; + // return this scaled by float f as a new fector + Vec2.prototype.scale = function(f){ + return new Vec2(this.x*f, this.y*f); + }; + // return the negation of this vector + Vec2.prototype.neg = function(f){ + return new Vec2(-this.x,-this.y); + }; + // return this vector normalized as a new vector + Vec2.prototype.normalize = function(){ + var len = this.len(); + if(len == 0){ + return new Vec2(0,1); + }else if(len != 1){ + return this.scale(1.0/len); + } + return new Vec2(this.x,this.y); + }; + // return a new vector with the same direction as this vector of length float l. (negative values of l will invert direction) + Vec2.prototype.set_len = function(l){ + return this.normalize().scale(l); + }; + // return the projection of this onto the vector v as a new vector + Vec2.prototype.project = function(v){ + return v.set_len(this.dot(v)); + }; + // return a string representation of this vector + Vec2.prototype.toString = function(){ + var str = ""; + str += "["; + str += this.x; + str += ","; + str += this.y; + str += "]"; + return str; + }; + //return this vector counterclockwise rotated by rad radians as a new vector + Vec2.prototype.rotate = function(rad){ + var c = Math.cos(rad); + var s = Math.sin(rad); + var px = this.x * c - this.y *s; + var py = this.x * s + this.y *c; + return new Vec2(px,py); + }; + //return this vector counterclockwise rotated by deg degrees as a new vector + Vec2.prototype.rotate_deg = function(deg){ + return this.rotate(deg * deg2rad); + }; + //linearly interpolate this vector towards the vector v by float factor alpha. + // alpha == 0 : does nothing + // alpha == 1 : sets this to v + Vec2.prototype.lerp = function(v,alpha){ + var inv_alpha = 1 - alpha; + return new Vec2( this.x * inv_alpha + v.x * alpha, + this.y * inv_alpha + v.y * alpha ); + }; + // returns the angle between this vector and the vector (1,0) in radians + Vec2.prototype.angle = function(){ + return Math.atan2(this.y,this.x); + }; + // returns the angle between this vector and the vector (1,0) in degrees + Vec2.prototype.angle_deg = function(){ + return Math.atan2(this.y,this.x) * rad2deg; + }; + // returns true if this vector is equal to the vector v, with a tolerance defined by the epsilon module constant + Vec2.prototype.equals = function(v){ + if(Math.abs(this.x-v.x) > epsilon){ + return false; + }else if(Math.abs(this.y-v.y) > epsilon){ + return false; + } + return true; + }; + // returns true if this vector is equal to the vector (x,y) with a tolerance defined by the epsilon module constant + Vec2.prototype.equals_xy = function(x,y){ + if(Math.abs(this.x-x) > epsilon){ + return false; + }else if(Math.abs(this.y-y) > epsilon){ + return false; + } + return true; + }; +})(window); + +(function(window){ + // A Bounding Shapes Library + + + // A Bounding Ellipse + // cx,cy : center of the ellipse + // rx,ry : radius of the ellipse + function BEllipse(cx,cy,rx,ry){ + this.type = 'ellipse'; + this.x = cx-rx; // minimum x coordinate contained in the ellipse + this.y = cy-ry; // minimum y coordinate contained in the ellipse + this.sx = 2*rx; // width of the ellipse on the x axis + this.sy = 2*ry; // width of the ellipse on the y axis + this.hx = rx; // half of the ellipse width on the x axis + this.hy = ry; // half of the ellipse width on the y axis + this.cx = cx; // x coordinate of the ellipse center + this.cy = cy; // y coordinate of the ellipse center + this.mx = cx + rx; // maximum x coordinate contained in the ellipse + this.my = cy + ry; // maximum x coordinate contained in the ellipse + } + window.BEllipse = BEllipse; + + // returns an unordered list of vector defining the positions of the intersections between the ellipse's + // boundary and a line segment defined by the start and end vectors a,b + BEllipse.prototype.collide_segment = function(a,b){ + // http://paulbourke.net/geometry/sphereline/ + var collisions = []; + + if(a.equals(b)){ //we do not compute the intersection in this case. TODO ? + return collisions; + } + + // make all computations in a space where the ellipse is a circle + // centered on zero + var c = new Vec2(this.cx,this.cy); + a = a.sub(c).mult_xy(1/this.hx,1/this.hy); + b = b.sub(c).mult_xy(1/this.hx,1/this.hy); + + + if(a.len_sq() < 1 && b.len_sq() < 1){ //both points inside the ellipse + return collisions; + } + + // compute the roots of the intersection + var ab = b.sub(a); + var A = (ab.x*ab.x + ab.y*ab.y); + var B = 2*( ab.x*a.x + ab.y*a.y); + var C = a.x*a.x + a.y*a.y - 1; + var u = B * B - 4*A*C; + + if(u < 0){ + return collisions; + } + + u = Math.sqrt(u); + var u1 = (-B + u) / (2*A); + var u2 = (-B - u) / (2*A); + + if(u1 >= 0 && u1 <= 1){ + var pos = a.add(ab.scale(u1)); + collisions.push(pos); + } + if(u1 != u2 && u2 >= 0 && u2 <= 1){ + var pos = a.add(ab.scale(u2)); + collisions.push(pos); + } + for(var i = 0; i < collisions.length; i++){ + collisions[i] = collisions[i].mult_xy(this.hx,this.hy); + collisions[i] = collisions[i].add_xy(this.cx,this.cy); + } + return collisions; + }; + + // A bounding rectangle + // x,y the minimum coordinate contained in the rectangle + // sx,sy the size of the rectangle along the x,y axis + function BRect(x,y,sx,sy){ + this.type = 'rect'; + this.x = x; // minimum x coordinate contained in the rectangle + this.y = y; // minimum y coordinate contained in the rectangle + this.sx = sx; // width of the rectangle on the x axis + this.sy = sy; // width of the rectangle on the y axis + this.hx = sx/2; // half of the rectangle width on the x axis + this.hy = sy/2; // half of the rectangle width on the y axis + this.cx = x + this.hx; // x coordinate of the rectangle center + this.cy = y + this.hy; // y coordinate of the rectangle center + this.mx = x + sx; // maximum x coordinate contained in the rectangle + this.my = y + sy; // maximum x coordinate contained in the rectangle + } + + window.BRect = BRect; + // Static method creating a new bounding rectangle of size (sx,sy) centered on (cx,cy) + BRect.new_centered = function(cx,cy,sx,sy){ + return new BRect(cx-sx/2,cy-sy/2,sx,sy); + }; + //intersect line a,b with line c,d, returns null if no intersection + function line_intersect(a,b,c,d){ + // http://paulbourke.net/geometry/lineline2d/ + var f = ((d.y - c.y)*(b.x - a.x) - (d.x - c.x)*(b.y - a.y)); + if(f == 0){ + return null; + } + f = 1 / f; + var fab = ((d.x - c.x)*(a.y - c.y) - (d.y - c.y)*(a.x - c.x)) * f ; + if(fab < 0 || fab > 1){ + return null; + } + var fcd = ((b.x - a.x)*(a.y - c.y) - (b.y - a.y)*(a.x - c.x)) * f ; + if(fcd < 0 || fcd > 1){ + return null; + } + return new Vec2(a.x + fab * (b.x-a.x), a.y + fab * (b.y - a.y) ); + } + + // returns an unordered list of vector defining the positions of the intersections between the ellipse's + // boundary and a line segment defined by the start and end vectors a,b + + BRect.prototype.collide_segment = function(a,b){ + var collisions = []; + var corners = [ new Vec2(this.x,this.y), new Vec2(this.x,this.my), + new Vec2(this.mx,this.my), new Vec2(this.mx,this.y) ]; + var pos = line_intersect(a,b,corners[0],corners[1]); + if(pos) collisions.push(pos); + pos = line_intersect(a,b,corners[1],corners[2]); + if(pos) collisions.push(pos); + pos = line_intersect(a,b,corners[2],corners[3]); + if(pos) collisions.push(pos); + pos = line_intersect(a,b,corners[3],corners[0]); + if(pos) collisions.push(pos); + return collisions; + }; + + // returns true if the rectangle contains the position defined by the vector 'vec' + BRect.prototype.contains_vec = function(vec){ + return ( vec.x >= this.x && vec.x <= this.mx && + vec.y >= this.y && vec.y <= this.my ); + }; + // returns true if the rectangle contains the position (x,y) + BRect.prototype.contains_xy = function(x,y){ + return ( x >= this.x && x <= this.mx && + y >= this.y && y <= this.my ); + }; + // returns true if the ellipse contains the position defined by the vector 'vec' + BEllipse.prototype.contains_vec = function(v){ + v = v.mult_xy(this.hx,this.hy); + return v.len_sq() <= 1; + }; + // returns true if the ellipse contains the position (x,y) + BEllipse.prototype.contains_xy = function(x,y){ + return this.contains(new Vec2(x,y)); + }; + + +})(window); + + |