awv3
Version:
⚡ AWV3 embedded CAD
522 lines (476 loc) • 19.7 kB
JavaScript
'use strict';
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.default = undefined;
var _getPrototypeOf = require('babel-runtime/core-js/object/get-prototype-of');
var _getPrototypeOf2 = _interopRequireDefault(_getPrototypeOf);
var _classCallCheck2 = require('babel-runtime/helpers/classCallCheck');
var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);
var _createClass2 = require('babel-runtime/helpers/createClass');
var _createClass3 = _interopRequireDefault(_createClass2);
var _possibleConstructorReturn2 = require('babel-runtime/helpers/possibleConstructorReturn');
var _possibleConstructorReturn3 = _interopRequireDefault(_possibleConstructorReturn2);
var _inherits2 = require('babel-runtime/helpers/inherits');
var _inherits3 = _interopRequireDefault(_inherits2);
var _defineProperty2 = require('babel-runtime/helpers/defineProperty');
var _defineProperty3 = _interopRequireDefault(_defineProperty2);
var _extends3 = require('babel-runtime/helpers/extends');
var _extends4 = _interopRequireDefault(_extends3);
var _three = require('three');
var THREE = _interopRequireWildcard(_three);
var _plugin = require('../../session/plugin');
var _plugin2 = _interopRequireDefault(_plugin);
var _elements = require('../../session/elements');
var _object = require('../../three/object3');
var _object2 = _interopRequireDefault(_object);
function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
/**
* @module Measure plugin for awv3
*/
var resources = ['measure'].reduce(function (prev, item) {
return (0, _extends4.default)({}, prev, (0, _defineProperty3.default)({}, item, require('!!url-loader!awv3-icons/32x32/' + item + '.png')));
}, {});
/**
* Class Measure is based on awv3's plugin architecture. It calculates distances
* and angles between various selected geometry elements.
*/
var Measure = function (_Plugin) {
(0, _inherits3.default)(Measure, _Plugin);
function Measure(session, args) {
(0, _classCallCheck3.default)(this, Measure);
var _this = (0, _possibleConstructorReturn3.default)(this, (Measure.__proto__ || (0, _getPrototypeOf2.default)(Measure)).call(this, session, (0, _extends4.default)({ type: 'Measure', icon: 'measure', resources: resources }, args)));
_this.selection = new _elements.Selection(_this, { name: 'Items', types: ['Mesh', 'LineSegments', 'Point'] });
_this.addElement(_this.selection);
_this.measureLabels = new _elements.Group(_this, { format: _elements.Group.Format.Table });
_this.addElement(_this.measureLabels);
_this.scene = null;
// maximum number of labels
_this.maxNofLabels = 10;
return _this;
}
(0, _createClass3.default)(Measure, [{
key: 'onEnabled',
value: function onEnabled() {
var _this2 = this;
// 6. You can call resetElements() here, this will reset() each element to its original state
// You can also call reset() manually on elements.
this.resetElements();
// 7. To react to an element you can observe its properties as they are tied to the state-tree.
// The Element class offers the observe() function targeted to its state, just like session and plugin do
// selection changed
this.selection.observe(function (state) {
return state.children;
}, function (value) {
// get selected items, put them in an array
var selectedItems = _this2.session.selector.getSelectedElements();
var info = _this2.solve(selectedItems);
_this2.measureLabels.removeAllChilds();
info.forEach(function (item) {
return _this2.measureLabels.addChild(new _elements.Label(_this2, { name: item.description, value: item.result }));
});
});
window.selection = this.selection;
// TODO: This should be done by selector.js, the values depend on the model-size
// Store original interaction values
//this.linePrecision = this.session.pool.view.interaction.raycaster.linePrecision
//this.session.pool.view.interaction.raycaster.linePrecision = 0.1
this.scene = this.session.pool.scene;
}
}, {
key: 'onDisabled',
value: function onDisabled() {
// restore original interaction values
//this.session.pool.view.interaction.raycaster.linePrecision = this.linePrecision
}
}, {
key: 'onDestroyed',
value: function onDestroyed() {}
/**
* This function triggers the calculation of distances / angles between
* two geometry objects or gets a description for each selected object
* if the number of objects is not equal to two.
*/
}, {
key: 'solve',
value: function solve(objects) {
// this.storeSelectedIds(objects)
switch (objects.length) {
case 2:
return Measure.calculateMeasures(objects);
default:
return objects.map(function (item) {
return Measure.getInfo(item);
});
}
}
/**
* Collects information about a single geometry element
* @param {three object} element - the three geometry element
* @return { object } - Calculated information object with result
* {number} and description {string}
*/
}], [{
key: 'getInfo',
value: function getInfo(element) {
switch (element.meta.type) {
case 'point':
var info = element.meta.position.toArray();
return {
result: '[ ' + info.join(', ') + ' ]',
description: 'Position'
};
case 'line':
{
var absoluteDistance = element.meta.start.distanceTo(element.meta.end);
absoluteDistance = Measure.round(absoluteDistance, 3);
return {
result: absoluteDistance,
description: 'Line length'
};
}
case 'arc':
{
var radius = element.meta.radius;
return {
result: radius,
description: 'Arc radius'
};
}
case 'circle':
{
var _radius = element.meta.radius;
return {
result: _radius,
description: 'Circle radius'
};
}
case 'nurbs':
return {
result: 0,
description: 'NURBS'
};
case 'plane':
{
var _info = element.meta.normal.toArray();
return {
result: '[ ' + _info.join(', ') + ' ]',
description: 'Plane normal'
};
}
case 'cylinder':
{
var _radius2 = element.meta.radius;
return {
result: _radius2,
description: 'Cylinder radius'
};
}
case 'cone':
{
return {
result: 0,
description: 'Cone'
};
}
case 'sphere':
{
var _radius3 = element.meta.radius;
return {
result: _radius3,
description: 'Sphere radius'
};
}
case 'nurbsSurface':
return {
result: 0,
description: 'NURBS Surface'
};
default:
return {
result: 0,
description: 'Undefined'
};
}
}
}, {
key: 'calculateMeasures',
value: function calculateMeasures(objects) {
var first = objects[0];
var second = objects[1];
var results = [];
switch (first.meta.type) {
case 'point':
switch (second.meta.type) {
case 'point':
{
results = Measure.calculatePointPoint(first, second);
}
break;
case 'line':
{
results = Measure.calculatePointLine(first, second);
}
break;
case 'plane':
{
results = Measure.calculatePointPlane(first, second);
}
}
break;
case 'line':
{
switch (second.meta.type) {
case 'point':
{
results = Measure.calculatePointLine(second, first);
}
break;
case 'line':
{
results = Measure.calculateLineLine(first, second);
}
break;
case 'plane':
{
results = Measure.calculateLinePlane(first, second);
}
}
}
break;
case 'plane':
{
switch (second.meta.type) {
case 'point':
{
results = Measure.calculatePointPlane(second, first);
}
break;
case 'line':
{
results = Measure.calculateLinePlane(second, first);
}
break;
case 'arc':
{
results = Measure.calculateArcPlane(first, second);
}
break;
case 'plane':
{
results = Measure.calculatePlanePlane(first, second);
}
}
}
}
return results;
}
}, {
key: 'calculatePointPoint',
value: function calculatePointPoint(point1, point2) {
var distance = Measure.distancePointPoint(point1, point2);
distance = Measure.round(distance, 3);
var dx = Measure.round(Math.abs(point1.meta.position.x - point2.meta.position.x), 3);
var dy = Measure.round(Math.abs(point1.meta.position.y - point2.meta.position.y), 3);
var dz = Measure.round(Math.abs(point1.meta.position.z - point2.meta.position.z), 3);
return [{
result: distance,
description: 'Distance'
}, {
result: dx,
description: 'dx'
}, {
result: dy,
description: 'dy'
}, {
result: dz,
description: 'dz'
}];
}
}, {
key: 'calculatePointLine',
value: function calculatePointLine(point, line) {
var distance = Measure.distancePointLine(point.meta.position, line);
distance = Measure.round(distance, 3);
return [{
result: distance,
description: 'Distance'
}];
}
}, {
key: 'calculatePointPlane',
value: function calculatePointPlane(point, plane) {
var distance = Measure.distancePointPlane(point.meta.position, plane);
distance = Measure.round(distance, 3);
return [{
result: distance,
description: 'Distance'
}];
}
}, {
key: 'calculateLineLine',
value: function calculateLineLine(first, second) {
var distance = Measure.distanceLineLine(first, second);
distance = Measure.round(distance, 3);
var angle = Measure.degrees(Measure.angleLineLine(first, second));
angle = Measure.round(angle, 3);
return [{
result: distance,
description: 'Distance'
}, {
result: angle,
description: 'Angle'
}];
}
}, {
key: 'calculateLinePlane',
value: function calculateLinePlane(line, plane) {
var distance = Measure.distanceLinePlane(line, plane);
distance = Measure.round(distance, 3);
return [{
result: distance,
description: 'Distance'
}];
}
}, {
key: 'calculateArcPlane',
value: function calculateArcPlane(arc, plane) {
var distance = Measure.distanceArcPlane(arc, plane);
distance = Measure.round(distance, 3);
return [{
result: distance,
description: 'Distance'
}];
}
}, {
key: 'calculatePlanePlane',
value: function calculatePlanePlane(plane1, plane2) {
var distance = Measure.distancePlanePlane(plane1, plane2);
distance = Measure.round(distance, 3);
var angle = Measure.degrees(Measure.anglePlanePlane(plane1, plane2));
angle = Measure.round(angle, 3);
return [{
result: distance,
description: 'Distance'
}, {
result: angle,
description: 'Angle'
}];
}
}, {
key: 'isNullVector',
value: function isNullVector(vec) {
var tolerance = 1e-12;
if (Math.abs(vec.x) < tolerance && Math.abs(vec.y) < tolerance && Math.abs(vec.z) < tolerance) {
return true;
} else {
return false;
}
}
}, {
key: 'distancePointPoint',
value: function distancePointPoint(point1, point2) {
return point1.meta.position.clone().distanceTo(point2.meta.position);
}
}, {
key: 'distancePointLine',
value: function distancePointLine(pointPosition, line) {
var vec = line.meta.start.clone().sub(line.meta.end);
var vecAB = line.meta.start.clone().sub(pointPosition);
var distance = 0;
var length = vec.length();
if (length > 0) {
distance = vec.cross(vecAB).length() / length;
}
return distance;
}
}, {
key: 'distanceLineLine',
value: function distanceLineLine(line1, line2) {
var vec1 = line1.meta.start.clone().sub(line1.meta.end);
var vec2 = line2.meta.start.clone().sub(line2.meta.end);
var nVec = vec1.clone().cross(vec2);
var distance = 0;
if (Measure.isNullVector(nVec)) {
// lines are parallel
var vecAB = line1.meta.start.clone().sub(line2.meta.start);
var nVec2 = vecAB.clone().cross(vec1);
if (!Measure.isNullVector(nVec2)) {
// lines are not conincident
return Measure.distancePointLine(line1.meta.start, line2);
}
} else {
distance = Math.abs(nVec.clone().dot(line2.meta.start.clone().sub(line1.meta.start)) / nVec.length());
}
return distance;
}
}, {
key: 'distanceLinePlane',
value: function distanceLinePlane(line, plane) {
var vec = line.meta.start.clone().sub(line.meta.end);
var product = vec.dot(plane.meta.normal);
if (product < 1e-12) {
// line is parallel to plane
return Measure.distancePointPlane(line.meta.start, plane);
}
}
}, {
key: 'distanceArcPlane',
value: function distanceArcPlane(arc, plane) {
var vec = arc.meta.normal.clone().cross(plane.meta.normal);
if (Measure.isNullVector(vec)) {
// parallel
return Measure.distancePointPlane(arc.meta.center, plane);
}
}
}, {
key: 'distancePointPlane',
value: function distancePointPlane(pointPosition, plane) {
var normal = plane.meta.normal.normalize();
var d = -1 * plane.meta.pointOnPlane.clone().dot(normal);
var distance = Math.abs(normal.clone().dot(pointPosition) + d) / normal.length();
return distance;
}
}, {
key: 'distancePlanePlane',
value: function distancePlanePlane(plane1, plane2) {
var vec = plane1.meta.normal.clone().cross(plane2.meta.normal);
if (Measure.isNullVector(vec)) {
// parallel
return Measure.distancePointPlane(plane1.meta.pointOnPlane, plane2);
} else {
return 0;
}
}
}, {
key: 'angleLineLine',
value: function angleLineLine(line1, line2) {
var vec1 = line1.meta.start.clone().sub(line1.meta.end);
var vec2 = line2.meta.start.clone().sub(line2.meta.end);
var angle = vec1.angleTo(vec2);
return angle;
}
}, {
key: 'anglePlanePlane',
value: function anglePlanePlane(plane1, plane2) {
var normal1 = plane1.meta.normal;
var normal2 = plane2.meta.normal;
var angle = normal1.angleTo(normal2);
return angle;
}
}, {
key: 'degrees',
value: function degrees(radians) {
return radians / Math.PI * 180;
}
}, {
key: 'round',
value: function round(value, digits) {
var factor = Math.pow(10, digits);
return Math.round(value * factor) / factor;
}
}]);
return Measure;
}(_plugin2.default);
exports.default = Measure;