///////////////////////////////////////////////////////
//  !!! Используется спецификация javascript ES6(ES2015) !!!
///////////////////////////////////////////////////////

///////////////////////////////////////////////////////
// функции для работы с консолью:
///////////////////////////////////////////////////////

// вывести в консоль строку
console.log('log text');
console.log('text1', 'text2');
console.log('text1', 'text2', .. , 'text10');
// вывести в консоль информационную строку
console.info('info text');
console.info('text1', 'text2');
console.info('text1', 'text2', .. , 'text10');
// вывести в консоль предупреждение
console.warn('warning text');
console.warn('text1', 'text2');
console.warn('text1', 'text2', .. , 'text10');
// вывести в консоль ошибку
console.error('critical text');
console.error('text1', 'text2');
console.error('text1', 'text2', .. , 'text10');
//очистить окно консоли
console.clear();
// вывести в консоль содержимое объекта 'object'
console.dir(object);

///////////////////////////////////////////////////////
// Глобальные функции 
///////////////////////////////////////////////////////

// включение скрипта
include(path)

// загрузка модуля
let m = require(path)

///////////////////////////////////////////////////////
// функции для работы с файлами
///////////////////////////////////////////////////////
let result = writeFile("<path_to_file>", "content_of_file", append = true); // append = true - добавить в файл, иначе перед записью файл усекается
// result = true, если успешно

let content = readFile("<path_to_file>"); // content - содержимое файла



///////////////////////////////////////////////////////
// Дополнительные функции Math
///////////////////////////////////////////////////////
Math.fuzzyIsNull(value, eps)
Math.fuzzyIsEqual(v1, v2, eps)

Math.rad(degrees) // degrees to radians
Math.deg(radians) // radians to degrees

// перевод полярных координат в декартовы координаты
Math.fromPolar(length, angle)

// нормализация угла
Math.normAngle(a) // return 'a' in range [0, 360)

// расчет среднего угла между углами a1 и a2 и учетом направления (CW - по часовой стрелке, CCW - против часовой стрелки)
Math.middleAngle(a1, a2, dir) // return middle angle for 'a1' -> 'a2', dir = [Coil.CW | Coil.CCW]

///////////////////////////////////////////////////////
// Встроенный объект Мotor
///////////////////////////////////////////////////////
// Тип машины
motor.machineType;// одно из значений:
	Motor.SR;	// 0, stator - rotor
	Motor.SRS;  // 1, stator - rotor - stator
	Motor.SRSRS;// 2, stator - rotor - stator - rotor - stator
	Motor.RSR;	// 3, rotor - stator - rotor
	Motor.RSRSR;// 4, rotor - stator - rotor - stator - rotor

motor.objectName; // READONLY
motor.height;
motor.periodicity;
motor.periodicityAngleSpan;
motor.boundaryConditionMode;
motor.boundaryCondition;
motor.simDomain; // READONLY, return SimDomain
motor.simRadialOuterDomain; // READONLY

motor.stator; // возвращает объект stator (см. ниже)
motor.rotor; // возвращает объект rotor (см. ниже)
motor.winding; // возвращает объект winding (см. ниже)
motor.mesh; // возвращает объект mesh (см. ниже)

///////////////////////////////////////////////////////
// Встроенный объект Stator
///////////////////////////////////////////////////////
Stator.Yokeless; // 0
Stator.Yoke;     // 1

stator.objectName; // READONLY
stator.outerDiameter;
stator.outerRadius;
stator.innerDiameter;
stator.innerRadius;
stator.numberSlots;// количество пазов статора
stator.slotAngleSpan; // READONLY
stator.typeMiddleItem; // Stator.Yokeless, Stator.Yoke
stator.ironMaterial;
stator.ironStacking;
stator.windingMaterial;
stator.windingTemperature;
stator.script;
stator.nameScript; //READONLY

stator.countItem; // 1...3, зависит от motor.machineType
stator.items; // array of StatorItem, зависит от motor.machineType

stator.item(itemID); // возвращает объект StatorItem (см. ниже)
stator.isLower(itemID);
stator.isMiddle(itemID);
stator.isUpper(itemID);
stator.itemAngularDisplacement(layoutIndex);
stator.setItemAngularDisplacement(layoutIndex, angle);

stator.simDomain; READONLY, return SimDomain
stator.simRadialOuterDomain; // READONLY

///////////////////////////////////////////////////////
// Встроенный объект StatorItem
///////////////////////////////////////////////////////
StatorItem.ID1; // 1
StatorItem.ID2; // 2
StatorItem.ID3; // 3

StatorItem.LayerLower; // 1
StatorItem.LayerUpper; // 2

statorItem.objectName; // READONLY
statorItem.id; // READONLY, StatorItem.ID1, StatorItem.ID2, StatorItem.ID3
statorItem.height;

statorItem.isUpper()
statorItem.isMiddle()
statorItem.isLower()
statorItem.angularDisplacement(layer); // StatorItem.LayerLower, StatorItem.LayerUpper 
statorItem.setAngularDisplacement(layer, angle); // StatorItem.LayerLower, StatorItem.LayerUpper 

///////////////////////////////////////////////////////
// Встроенный объект Rotor
///////////////////////////////////////////////////////
Rotor.Yokeless; // 1
Rotor.Yoke;     // 2

PoleArrangement.NN; // 0
PoleArrangement.NS; // 1
PoleArrangement.NSNS; // 2
PoleArrangement.NSSN; // 3
PoleArrangement.NNSS; // 4
PoleArrangement.NNNN; // 5

rotor.outerDiameter;
rotor.outerRadius;
rotor.innerDiameter;
rotor.innerRadius;
rotor.numberPolePairs;
rotor.poleAngleSpan; // READONLY
rotor.poleArrangement; // PoleArrangement.NN ... PoleArrangement.NNNN
rotor.typeMiddleItem; // Rotor.Yokeless, Rotor.Yoke
rotor.ironStacking;
rotor.ironMaterial;
rotor.magnetTemperature;
rotor.magnetMaterial;
rotor.conductorTemperature;
rotor.conductorMaterial;
rotor.script;
rotor.nameScript;//READONLY

rotor.countItem; // 1...3, зависит от motor.machineType
rotor.items; // array of RotorItem, зависит от motor.machineType

rotor.item(itemID); // возвращает объект RotorItem (см. ниже)
rotor.isLower(itemID);
rotor.isMiddle(itemID);
rotor.isUpper(itemID);
rotor.itemAngularDisplacement(layoutIndex);
rotor.setItemAngularDisplacement(layoutIndex, angle);

rotor.simDomain; // READONLY, return SimDomain
rotor.simRadialOuterDomain; // READONLY

///////////////////////////////////////////////////////
// Встроенный объект RotorItem
///////////////////////////////////////////////////////
RotorItem.ID1; // 1
RotorItem.ID2; // 2
RotorItem.ID3; // 3

RotorItem.LayerLower; // 1
RotorItem.LayerUpper; // 2

rotorItem.objectName; //READONLY
rotorItem.id; //READONLY, RotorItem.ID1, RotorItem.ID2, RotorItem.ID3
rotorItem.height;

rotorItem.isUpper();
rotorItem.isMiddle();
rotorItem.isLower();
rotorItem.angularDisplacement(layer); // RotorItem.LayerLower, RotorItem.LayerUpper 
rotorItem.setAngularDisplacement(layer, angle); // RotorItem.LayerLower, RotorItem.LayerUpper 

///////////////////////////////////////////////////////
// Встроенный объект Coil
///////////////////////////////////////////////////////
Coil.CW
Coil.CCW

///////////////////////////////////////////////////////
// Встроенный объект Winding
///////////////////////////////////////////////////////
// Type
Winding.Planar; // 1
Winding.Toroidal; // 2

// Number layers
Winding.SingleLayer; // 1
Winding.DoubleLayer; // 2

//LayersOrientation
Winding.UpperLower; // 1
Winding.LeftRight; // 2

// Circuit
Winding.Star; // 1
Winding.Delta; // 2

// Connection
'1-2'         
'1||2'        
'1-2-3'       
'1||2||3'     
'1-2-3-4'     
'1||2||3||4'  
'(1-2)||(3-4)'
'(1-3)||(2-4)'
'(1-4)||(2-3)'

winding.objectName; //READONLY
winding.circuit; // Winding.Star, Winding.Delta
winding.statorConnection; // Connection
winding.parallelPaths;
winding.numberTurns;
winding.strandsConductor;
winding.numberOuterSegments

winding.type; // Winding.Planal, Winding.Toroidal
winding.isPlanar();
winding.isToroidal();

winding.numberLayers; // Winding.SingleLayer, Winding.DoubleLayer
winding.isSingleLayer();
winding.isDoubleLayer();

winding.layersOrientation; // Winding.UpperLower, Winding.LeftRight
winding.isOrientationUpperLower();
winding.isOrientationLeftRight();

winding.autoCalcOverhandEndturns; //READONLY

winding.radialOverhandOuterEndturn; //Write only for winding.autoCalcOverhandEndturns == true
winding.radialOverhandInnerEndturn; //Write only for winding.autoCalcOverhandEndturns == true

winding.heightOuterEndturn; // Outer end turns height, for Winding single layer
winding.heightInnerEndturn; // Inner end turns height, for Winding single layer

// проверяет наличие пересечения элементов, =true - пересечение нет
winding.checkOverlapEndturns(items);
// расчитывает объем области пересечения элементов, если пересечения нет, то возвращает 0
winding.volumeOverlapEndturns(items);
// расчитывает расстояние между элементами, если элементов больше двух, то возвращает меньшее расстояние
winding.distanceBetweenEndturns(items);

///////////////////////////////////////////////////////
// Встроенный объект Mesh
///////////////////////////////////////////////////////
mesh.objectName; // READONLY
mesh.autoSizeBound; // false, true
mesh.sizeBound;
mesh.numberSlices: // 3,5,7,9
mesh.airgapQuality; // 0.5, 1.0, 1.5
mesh.horizontalSymmetry; // false, true

///////////////////////////////////////////////////////
// Встроенный объект SimDomain
///////////////////////////////////////////////////////
simDomain.inner;
simDomain.outer;

simDomain.range(); // return simDomain.outer - simDomain.inner

///////////////////////////////////////////////////////////////////////////////////////////////////////////////
// GeneralMaterial
///////////////////////////////////////////////////////////////////////////////////////////////////////////////
var materialGeneral = new GeneralMaterial;
var materialGeneral = Material.general();

///////////////////////////////////////////////////////////////////////////////////////////////////////////////
// IronMaterial
///////////////////////////////////////////////////////////////////////////////////////////////////////////////
var material Iron = new IronMaterial;
var materialIron = Material.iron();
// FillCoef - Material filling coefficient
// d_somaloy - Smallest cross section of component [m] for Somaloy material
var materialIron = Material.iron(FillCoef, d_somaloy);

///////////////////////////////////////////////////////////////////////////////////////////////////////////////
// WindingMaterial
///////////////////////////////////////////////////////////////////////////////////////////////////////////////
var materialWinding = new WindingMaterial(layer = 0);
var materialWinding = Material.winding(layer = 0);

///////////////////////////////////////////////////////////////////////////////////////////////////////////////
// EndturnMaterial
///////////////////////////////////////////////////////////////////////////////////////////////////////////////
var materialEndturn = new EndturnMaterial();
var materialEndturn = Material.endturn();

///////////////////////////////////////////////////////////////////////////////////////////////////////////////
// MagnetRadialMaterial
///////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Rmagnetsegnemt = массив радиусов сегментов магнита, размер должен быть равен значению Nmagnetsegments функции скрипта ротора getGeometry  и rotor.magnetSegmentsRadialDirection
var materialRadialMagnet = new MagnetRadialMaterial(direction = Magnetization.From, center = Qt.point(0,0), Rmagnetsegnemt = null);
var materialRadialMagnet = Material.magnetRadial(direction = Magnetization.From, center = Qt.point(0,0), Rmagnetsegnemt = null);

materialRadialMagnet.direction; // = Magnetization.From
// константы Magnetization
Magnetization.From
Magnetization.Toward
Magnetization.CW
Magnetization.CCW

materialRadialMagnet.center; // = Qt.point(0, 0);

///////////////////////////////////////////////////////////////////////////////////////////////////////////////
// MagnetParallelMaterial
///////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Rmagnetsegnemt = массив радиусов сегментов магнита, размер должен быть равен значению Nmagnetsegments функции скрипта ротора getGeometry  и rotor.magnetSegmentsRadialDirection
// Если savePoleBorder = true - сохраняем границу между магнитами двух соседних полюсов, если savePoleBorder = false - магнит сливается с магнитом соседнего полюса.
// Если savePoleBorder = false, но магниты для слияния имеют разное направление намагничивания или магниты не имеют общей границы, то границу сохраняем.
var materialParallelMagnet = new MagnetParallelMaterial(angle = 0, Rmagnetsegnemt = null, savePoleBorder = true);
var materialParallelMagnet = new Material.magnetParallel(angle = 0, Rmagnetsegnemt = null, savePoleBorder = true);

materialParallelMagnet.angle;

///////////////////////////////////////////////////////
// Встроенный объект Geom

// Углы задаются в градусах !!!

// точка из полярных координат (radius, angle)
let p = Geom.fromPolar(r, a); // p -> {x, y}

// угол точки
let a = Geom.angle(x, y); // ноль - на три часа, увеличение по часовой

// угол точки в плоскости YOZ
let a = Geom.angleX(point3); // ноль - на три часа, увеличение по часовой
// угол точки в плоскости XOZ
let a = Geom.angleY(point3); // ноль - на три часа, увеличение по часовой
// угол точки в плоскости XOY
let a = Geom.angleZ(point3); // ноль - на три часа, увеличение по часовой

// создать вектор
let v = Geom.vector3;
let v = Geom.vector3(x, y, z);

// создать точку
let v = Geom.point3(); // point -> {0,0,0}
let v = Geom.point3(x, y, z); // point -> {x,y,z}
let v = Geom.point3(Qt.point(x, y), z = 0); // point -> {x,y,z}


// Отрезок обыкновенный, задаётся двумя точками.
let s = Geom.segment(p1, p2);

// Полисегмент - ломанная линия. Задаётся массивом точек point3
// Установка флага closed добавляет сегмент полилинии, идущий от точки конца к точке начала. points - массив точек.
let s = Geom.polysegment(points, closed); // points = [p1, p2, p3 ..], closed = true/false

// B-сплайн. Задаётся массивом точек point3
let s = Geom.bspline(points, closed); // points = [p1, p2, p3 ..], closed = true/false

// дуга
let arc = Geom.arc(r, angle); // радиус, угол (начальный угол = 0)
let arc = Geom.arc(r, a1, a2); // радиус, угол1, угол2
let arc = Geom.arc(p1, p2, p3); // дуга проходящяя через три точки

// 2D примитивы (плоские), строятся в плоскости XOY, углы задаются в градусах
// круг
let circ = Geom.circle(r);  // радиус
// сектор круга
let circ = Geom.circle(r, angle); // радиус, угол, тело центрируется относительно оси OX
// сектор круга
let circ = Geom.circle(r, a1, a2); // радиус, угол1, угол2

// эллипс
let ellipse = Geom.ellipse(r1, r2);
let ellipse = Geom.ellipse(r1, r2, a1, a2);

// кольцо
let ring = Geom.ring(r1, r2); // наружний радиус, внутренний радиус
// сектор кольца
let ring = Geom.ring(r1, r2, angle); // тело центрируется относительно оси OX
// сектор кольца
let ring = Geom.ring(r1, r2, a1, a2);

// правильный многоугольник
let ngon = Geom.ngon(r, n); // радиус, количество углов > 2
// квадрат
let square = Geom.square(a); // сторона
// прямоугольник, в плоскости XOY
let rect = Geom.rectangle(a, b);// сторона по X, Y
// многоугольник, в плоскости XOY
let poly = Geom.polygon(points);// массив вершин

// плоскость, pos - позиция, dir - вектор перпендикулярный проскости
let infplane = Geom.infplane(pos = point(0,0,0), dir = vector3(0,0,1))

// 3D примитивы (объемные), углы задаются в радианах
// параллелипипед. Задаётся с указанием трёх размеров x, y, z
let box = Geom.box(x, y, z);
let box = Geom.box(a); // куб (a,a,a)

// цилиндр. Задаётся с указанием радиуса r и высоты h.
// Возможно построение сектора цилиндра с использованием параметра angle
let cyl = Geom.cylinder(r, h);
let cyl = Geom.cylinder(r, h, angle); // тело центрируется относительно оси OX

// цилиндр с осевым отверстием. Задаётся с указанием внешненго радиуса r1, внутреннего радиуса r2 и высоты h.
// Возможно построение сектора цилиндра с использованием параметра angle
let col = Geom.collar(r1, r2, h);
let col = Geom.collar(r1, r2, h, angle); // тело центрируется относительно оси OX

// конус. Задаётся с указанием нижнего радиуса r1, верхнего радиуса r2 и высоты h.
// Возможно построение сектора конуса с использованием параметра angle.
let cone = Geom.cone(r1, r2, h);
let cone = Geom.cone(r1, r2, h, angle);

// сфера
let sphere = Geom.sphere(r);
let sphere = Geom.sphere(r, an1);
let sphere = Geom.sphere(r, an1, an2);
let sphere = Geom.sphere(r, an1, an2, an3);

// тор
let torus = Geom.torus(r1, r2);
let torus = Geom.torus(r1, r2, ua);
let torus = Geom.torus(r1, r2, va1, va2);
let torus = Geom.torus(r1, r2, va1, va2, ua);



// Булевы операции
// объединить два тела
let shape = Geom.unite(a, b); // a + b
let shape = Geom.unite(shapes);

// получить разность двух тел
let shape = Geom.difference(a, b); // a - b
let shape = Geom.diff(a, b); // a - b
let shape = Geom.difference(shapes);
let shape = Geom.diff(shapes);

// получить пересечение двух тел
let shape = Geom.intersect(a, b); // a & b
let shape = Geom.intersect(shapes);

// Операция скругления тела. Если тело объёмное - модификации подвергаются ребра. Если плоское - вершины.
// Скругления задаются радиусом r и масcивом ближайших точек refs к модифицируемым ребрам/вершинам
let shape = Geom.fillet(shp, r);
let shape = Geom.fillet(shp, r, refs);

// Операция взятия фаски тела. В отличие от скругления применяется только к объёмным телам.
// Фаска задаётся расстоянием r, взятым от ребра до линии фаски и масивом ближайших точек refs.
let shape = Geom.chamfer(shp, r);
let shape = Geom.chamfer(shp, r, refs);

// упрощает геометрическое представление объекта, путём удаления лишних рёбер и объединения граней.
let shape = Geom.unify(shp);

// длина кривой: segment, polysegment, bspline, arc
let len = s.length();

// площадь 2D фигуры (плоской)
let area = s.area();

// объем 3D фигуры
let volume = s.volume();

// центр (он же центр массы) фигуры, точка point3
let center = s.center()

// ограничивающая коробка / bounding box
let bbox = Geom.boundingBox(shape);

// свойства boundingBox
bbox.xmin;
bbox.xmax;
bbox.ymin;
bbox.ymax;
bbox.zmin;
bbox.zmax;
bbox.xcenter;
bbox.ycenter;
bbox.zcenter;

// создание детали (объемное тело с назначенным материалом)
// результат функции getGeometry()
let piece = Geom.piece(shape, material);
// создание детали (объемное тело с назначенным цветом)
let piece = Geom.piece(shape, color);
// где 'color' константа задающая цвет детали:
//Qt.black,
//Qt.white,
//Qt.darkGray,
//Qt.gray,
//Qt.lightGray,
//Qt.red,
//Qt.green,
//Qt.blue,
//Qt.cyan,
//Qt.magenta,
//Qt.yellow,
//Qt.darkRed,
//Qt.darkGreen,
//Qt.darkBlue,
//Qt.darkCyan,
//Qt.darkMagenta,
//Qt.darkYellow,


///////////////////////////////////////////////////////
// объект vector3
let vec = Geom.vector3();
let vec = Geom.vector3(x, y, z);

// свойства vector3
vec.x;
vec.y;
vec.z;

// длина вектора
let len = vec.lenght()

///////////////////////////////////////////////////////
// объект point3
let p = Geom.point3();
let p = Geom.point3(x, y, z);
let p = Geom.point3(Qt.point(x, y)); // p ->{x,y,0}
let p = Geom.point3(Qt.point(x, y), z); // p ->{x,y,z}

// свойства point3
p.x;
p.y;
p.z;

// расчет расстояния между точками
let dist = Geom.distance(p1, p2);
let dist = p1.distance(p2);

///////////////////////////////////////////////////////
// Аффинные преобразования точек аналогичны аффинным преобразованиям тел
///////////////////////////////////////////////////////
// Аффинные преобразования тел
// Translation API
let s = point.translate(x, y, z); //Паралельный перенос точки на вектор (x,y,z)
let s = point.translate(v);//Паралельный перенос точки на вектор v
let s = point.translateX(x);// as point.translate(x, 0, 0)
let s = point.translateY(y);// as point.translate(0, y, 0)
let s = point.translateZ(z);// as point.translate(0, 0, z)

let s = point.move(x, y, z); //as shape.translate(x, y, z) 
let s = point.move(v); // as shape.translate(v), v - vector3
let s = point.move(p); // as shape.translate(p) , p - point3
let s = point.moveX(x); // as shape.translate(x, 0, 0) 
let s = point.moveY(y); // as shape.translate(0, y, 0) 
let s = point.moveZ(z); // as shape.translate(0, 0, z) 

// mnemonics for translate operations:
let s = point.up(z); // as shape.translate(0, 0, +z)
let s = point.down(z); // as shape.translate(0, 0, -z)
let s = point.forw(y); // as shape.translate(0, +y, 0)
let s = point.back(y); // as shape.translate(0, -y, 0)
let s = point.right(x); // as shape.translate(+x, 0, 0)
let s = point.left(x); // as shape.translate(-x, 0, 0)

// Rotation API:
let s = point.rotate(a, vec); // Поворот точки вокруг оси заданной вектором v и проходящей через начало координат на угол a.
let s = point.rotate(x, y, z); // Поворот точки вокруг оси заданной вектором {x,y,z}. угол поворота берётся как радианная мера, численно равная модулю вектора v.
let s = point.rotateX(ax); // Поворот точки вокруг оси OX
let s = point.rotateY(ay); // Поворот точки вокруг оси OY
let s = point.rotateZ(az); // Поворот точки вокруг оси OZ

// Scale API:
let s = point.scale(s, center = point3(0,0,0)); // Изменение размера точки на коэффициент s, относительно тоски center
let s = point.scaleX(sx); // Изменение размера точки на коэффициент s по оси OX
let s = point.scaleY(sy); // Изменение размера точки на коэффициент s по оси OY
let s = point.scaleZ(sz); // Изменение размера точки на коэффициент s по оси OZ

// Mirror API;
let s = point.mirrorO(); // Операция отражения геометрии относительно цетра координат
let s = point.mirrorX(); // Операция отражения геометрии относительно оси OX
let s = point.mirrorY(); // Операция отражения геометрии относительно оси OY
let s = point.mirrorZ(); // Операция отражения геометрии относительно оси OZ
let s = point.mirrorXY(); // Операция отражения геометрии относительно плоскости XOY
let s = point.mirrorYZ(); // Операция отражения геометрии относительно плоскости YOZ
let s = point.mirrorXZ(); // Операция отражения геометрии относительно плоскости XOZ


///////////////////////////////////////////////////////
// Аффинные преобразования тел
// Translation API
let s = shape.translate(x, y, z); //Паралельный перенос тела на вектор (x,y,z)
let s = shape.translate(v);//Паралельный перенос тела на вектор v
let s = shape.translateX(x);// as shape.translate(x, 0, 0)
let s = shape.translateY(y);// as shape.translate(0, y, 0)
let s = shape.translateZ(z);// as shape.translate(0, 0, z)

let s = shape.move(x, y, z); //as shape.translate(x, y, z) 
let s = shape.move(v); // as shape.translate(v), v - vector3
let s = shape.move(p); // as shape.translate(p) , p - point3
let s = shape.moveX(x); // as shape.translate(x, 0, 0) 
let s = shape.moveY(y); // as shape.translate(0, y, 0) 
let s = shape.moveZ(z); // as shape.translate(0, 0, z) 

// mnemonics for translate operations:
let s = shape.up(z); // as shape.translate(0, 0, +z)
let s = shape.down(z); // as shape.translate(0, 0, -z)
let s = shape.forw(y); // as shape.translate(0, +y, 0)
let s = shape.back(y); // as shape.translate(0, -y, 0)
let s = shape.right(x); // as shape.translate(+x, 0, 0)
let s = shape.left(x); // as shape.translate(-x, 0, 0)

// Rotation API:
let s = shape.rotate(a, vec); // Поворот тела вокруг оси заданной вектором v и проходящей через начало координат на угол a.
let s = shape.rotate(x, y, z); // Поворот тела вокруг оси заданной вектором {x,y,z}. угол поворота берётся как радианная мера, численно равная модулю вектора v.
let s = shape.rotateX(ax); // Поворот тела вокруг оси OX
let s = shape.rotateY(ay); // Поворот тела вокруг оси OY
let s = shape.rotateZ(az); // Поворот тела вокруг оси OZ

// Scale API:
let s = shape.scale(s, center = point3(0,0,0)); // Изменение размера тела на коэффициент s, относительно тоски center
let s = shape.scaleX(sx); // Изменение размера тела на коэффициент s по оси OX
let s = shape.scaleY(sy); // Изменение размера тела на коэффициент s по оси OY
let s = shape.scaleZ(sz); // Изменение размера тела на коэффициент s по оси OZ

// Mirror API;
let s = shape.mirrorO(); // Операция отражения геометрии относительно цетра координат
let s = shape.mirrorX(); // Операция отражения геометрии относительно оси OX
let s = shape.mirrorY(); // Операция отражения геометрии относительно оси OY
let s = shape.mirrorZ(); // Операция отражения геометрии относительно оси OZ
let s = shape.mirrorXY(); // Операция отражения геометрии относительно плоскости XOY
let s = shape.mirrorYZ(); // Операция отражения геометрии относительно плоскости YOZ
let s = shape.mirrorXZ(); // Операция отражения геометрии относительно плоскости XOZ

// Булевы операции
let s = shape.unite(const QmlShape& oth); // as Geom.union(shape, oth)
let s = shape.diff(const QmlShape& oth); // as Geom.difference(shape, oth)
let s = shape.difference(const QmlShape& oth); // as Geom.difference(shape, oth)
let s = shape.intersect(const QmlShape& oth); // as Geom.intersect(shape, oth)

// Выдавливание, придания объёма плоскому объекту.
let s = shape.extrudeX(x); // Операция выдавливает плоское тело shape по оси OX
let s = shape.extrudeY(y); // Операция выдавливает плоское тело shape по оси OY
let s = shape.extrudeZ(z); // Операция выдавливает плоское тело shape по оси OZ
let s = shape.extrude(vec); // Операция выдавливает плоское тело shape по вектору vec
let s = shape.extrude(x, y, z); // Операция выдавливает плоское тело shape по вектору {x,y,z}


// UI Widgets
// компоновщик виджетов QGridLayout
let layout = new QGridLayout;
layout.addWidget(widget) // добавление виджета в компоновщик
layout.addWidget(w, row, column)// добавление виджета в заданную строку, колонку
layout.addWidget(w, row, column, rowSpan, columnSpan)// добавление виджета в заданную строку, колонку
layout.addWidgets(widget1, widget2, row = -1, column = 0)// добавление двух виджетов в заданную строку ( или в последнюю стоку при row = -1), колонку и колонку+1

// виджет для ввода числа
let w = new NumberEdit(parent = null);
w.value; // number
w.valueChanged; // сигнал при изменении значения

// виджет для ввода числа слотов
let w = NumberSlotSpinBox(parent = null);
w.value; // число слотов: 6, 9, 12, 15, 18 и т.д.
w.valueChanged; // сигнал при изменении значения

// виджет для выбора типа статора
let w = new StatorTypeComboBox(parent = null);
w.currentValue; // Stator.Yoke, Stator.Yokeless
w.currentValueChanged; // сигнал при изменении значения

// виджет для выбора типа ротора
let w = new RotorTypeComboBox(parent = null);
w.currentValue; // Rotor.Yoke, Rotor.Yokeless
w.currentValueChanged; // сигнал при изменении значения

// виджет для выбора числа слоев обмотки
let w = new WindingLayersComboBox(parent = null);
w.currentValue; // Windind.SingleLayer, Windind.DoubleLayer
w.currentValueChanged; // сигнал при изменении значения

// виджет для выбора ориентации слоев обмотки
let w = new WindingLayersOrientationComboBox(parent = null);
w.currentValue; // Winding.UpperLower, Winding.LeftRight
w.currentValueChanged; // сигнал при изменении значения

// виджет для выбора типа обмотки
let w = new WindingTypeComboBox(parent = null);
w.currentValue; // Winding.Planar, Winding.Toroidal
w.currentValueChanged; // сигнал при изменении значения

// виджет для выбора расположение полюсов
let w = new PoleArrangementComboBox(parent = null);
w.currentValue; // PoleArrangement.NN, PoleArrangement.NS, PoleArrangement.NSNS, PoleArrangement.NSSN, PoleArrangement.NNSS, PoleArrangement.NNNN
w.currentValueChanged; // сигнал при изменении значения
w.setItems([PoleArrangement.NN, PoleArrangement.NS, PoleArrangement.NSNS, PoleArrangement.NSSN, PoleArrangement.NNSS, PoleArrangement.NNNN]) // установить элементы

// виджет для выбора подключение статора
let w = new StatorConnectionComboBox(parent = null);
w.currentValue; // '1-2', '1||2', '1-2-3', '1||2||3', '1-2-3-4', '1||2||3||4', '(1-2)||(3-4)', '(1-3)||(2-4)', '(1-4)||(2-3)'
w.currentValueChanged; // сигнал при изменении значения
w.setItems(['1-2', '1||2', '1-2-3', '1||2||3', '1-2-3-4', '1||2||3||4', '(1-2)||(3-4)', '(1-3)||(2-4)', '(1-4)||(2-3)']) // установить элементы
