///////////////////////////////////////////////////////
// подключить файл скрипта
include("file.js");

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

///////////////////////////////////////////////////////
// функции которых нет в стандартном API, но могут быть полезны:
//
var rad = Math.degToRad(deg); // - преобразование градусов в радианы
var deg = Math.radToDeg(rad); // - преобразование радиан в градусы
var pt = Math.formPolar(radius, angle); // - получить точку типа QPointF из полярных координат (radius, angle) относительно центра в точке (0,0)

// самое маленькое число
Math.EPSILON; // = 0.000000000001

// проверки числа на ноль
var b = Math.fuzzyIsNull(v);
var b = Math.fuzzyIsNull(v, epsilon); // default epsilon = Math.EPSILON;

// сравнение двух чисел
var b = Math.fuzzyIsEqual(v1, v2);
var b = Math.fuzzyIsEqual(v1, v2, epsilon); // default epsilon = Math.EPSILON;

///////////////////////////////////////////////////////
// константы MachineType
// MachineType.InnerRotor;
// MachineType.OuterRotor;
// Тип мотора: InnerRotor или OuterRotor
var mt = motor.machineType;// return MachineType.InnerRotor или MachineType.OuterRotor
// Установить мотор с внутренним ротором
motor.machineType = MachineType.InnerRotor;
// Установить мотор с внешним ротором
motor.machineType = MachineType.OuterRotor;
// проверить тип мотора
var innerRotor = motor.isInnerRotor(); // return true / false
var outerRotor = motor.isOuterRotor(); // return true / false
// вызов функции при изменении типа мотора, где value - актуальное значение
motor.machineTypeChangedChanged.connect( function(value) {
	console.log(value);
});

///////////////////////////////////////////////////////
// Количество пазов статора
var Nss = motor.statorNumberSlots;
motor.statorNumberSlots = Nss;
// вызов функции при изменении количества пазов, где value - актуальное значение
motor.statorNumberSlotsChanged.connect( function(value) {
	console.log(value);
});

///////////////////////////////////////////////////////
// Внешний диаметр статора
var Dso = motor.statorOuterDiameter;
motor.statorOuterDiameter = Dso;
// Внешний радиус статора, вычисляется из motor.statorOuterDiameter
var Rso = motor.statorOuterRadius; // = motor.statorOuterDiameter / 2;
motor.statorOuterRadius = Rso;
// вызов функции при изменении диаметра, где value - актуальное значение
motor.statorOuterDiameterChanged.connect( function(value) {
	console.log(value);
});

///////////////////////////////////////////////////////
// Внутренний диаметр статора
var Dsi = motor.statorInnerDiameter;
motor.statorInnerDiameter = Dsi;
// Внутренний радиус статора, вычисляется из motor.statorInnerDiameter
var Rsi = motor.statorInnerRadius; // = motor.statorInnerDiameter / 2;
motor.statorInnerRadius = Rsi;
// вызов функции при изменении диаметра, где value - актуальное значение
motor.statorInnerDiameterChanged.connect( function(value) {
	console.log(value);
});

///////////////////////////////////////////////////////
// количество слоев обмотки статора
var Nsl = motor.statorNumberSlotLayers;// return 1 или 2
motor.statorNumberSlotLayers = Nsl;
var singleLayer = motor.isStatorNumberSlotLayersSingle(); // return true / false
var doubleLayer = motor.isStatorNumberSlotLayersDouble(); // return true / false
// вызов функции при изменении количества слоев, где value - актуальное значение
motor.statorNumberSlotLayersChanged.connect( function(value) {
	console.log(value);
});

///////////////////////////////////////////////////////
// константы SlotLayersOrientation
// SlotLayersOrientation.UpperLower;
// SlotLayersOrientation.LeftRight;
// ориентация слоев статора, одно из значений
var Nso = motor.statorSlotLayersOrientation; // return SlotLayersOrientation.UpperLower / SlotLayersOrientation.LeftRight
motor.statorSlotLayersOrientation = Nso;
var ul = motor.isStatorSlotLayersOrientationUpperLower(); // true / false
var lr = motor.isStatorSlotLayersOrientationLeftRight(); // true / false
// вызов функции при изменении ориентации слоев, где value - актуальное значение
motor.statorSlotLayersOrientationChanged.connect( function(value) {
	console.log(value);
});

///////////////////////////////////////////////////////
// Имя файла скрипта статора
var Ss = motor.statorScript;

///////////////////////////////////////////////////////
// Воздушный зазор
var Ga = motor.airGap;
motor.airGap = Ga;
// расчитывается:
//	if (motor.machineType == InnerRotor)
//		motor.airGap = motor.statorInnerRadius - motor.rotorOuterRadius;
//	else// if (motor.machineType == OuterRotor)
//		motor.airGap =  motor.rotorInnerRadius - motor.statorOuterRadius;
// вызов функции при изменении воздушного зазора, где value - актуальное значение
motor.airGapChanged.connect( function(value) {
	console.log(value);
});

///////////////////////////////////////////////////////
// Внешний диаметр ротора
var Dro = motor.rotorOuterDiameter;
motor.rotorOuterDiameter = Dro;
// вызов функции при изменении внешнего диаметра ротора, где value - актуальное значение
motor.rotorOuterDiameterChanged.connect( function(value) {
	console.log(value);
});

///////////////////////////////////////////////////////
// Внешний радиус ротора
var Rro = motor.rotorOuterRadius;
motor.rotorOuterRadius = Rro;

///////////////////////////////////////////////////////
// Внутренний диаметр ротора
var Dri = motor.rotorInnerDiameter;
motor.rotorInnerDiameter = Dri;
// вызов функции при изменении внутреннего диаметра ротора, где value - актуальное значение
motor.rotorInnerDiameterChanged.connect( function(value) {
	console.log(value);
});

///////////////////////////////////////////////////////
// Внутренний радиус ротора
var Rri = motor.rotorInnerRadius;

///////////////////////////////////////////////////////
// Количество пар полюсов ротора
var Nrp = motor.rotorNumberPairPoles;
motor.rotorNumberPairPoles = Nrp;
// вызов функции при изменении количества пар полюсов ротора, где value - актуальное значение
motor.rotorNumberPairPolesChanged.connect(function (value) {
	console.log(value);
});

// Имя файла скрипта poтoрa
var Sr = motor.rotorScript;

///////////////////////////////////////////////////////////////////////////////////////////////////////////////
// GeneralMaterial
///////////////////////////////////////////////////////////////////////////////////////////////////////////////
var materialGeneral = new GeneralMaterial(10, 10);
//or var materialGeneral = new GeneralMaterialPoint( new QPointF(10, 10) );
//or var materialGeneral = new GeneralMaterialPoint;

materialGeneral.pos = new QPointF(10, 10);
// or materialGeneral.x = 10;
// or materialGeneral.y = 10;
var pos = materialGeneral.pos;

///////////////////////////////////////////////////////////////////////////////////////////////////////////////
// IronMaterial
///////////////////////////////////////////////////////////////////////////////////////////////////////////////
var materialIron = new IronMaterial(10, 10);
//var materialIron = new IronMaterial(new QPointF(10, 10));
//var materialIron = new IronMaterial;
materialIron.pos = new QPointF(10, 10);
//materialIron.x = 10;
//materialIron.y = 10;
var pos = materialIron.pos;

///////////////////////////////////////////////////////////////////////////////////////////////////////////////
// WindingMaterial
///////////////////////////////////////////////////////////////////////////////////////////////////////////////
var materialWinding = new WindingMaterial(10, 10);
// or var materialWinding = new WindingMaterial( new QPointF(10, 10) );
// or var materialWinding = new WindingMaterial;
materialWinding.pos = QPointF(10, 10);
//materialWinding.x = 10;
//materialWinding.y = 10;
var pos = materialWinding.pos;

materialWinding.layer = 1;
var layer = materialWinding.layer;

///////////////////////////////////////////////////////////////////////////////////////////////////////////////
// MagnetRadialMaterial
///////////////////////////////////////////////////////////////////////////////////////////////////////////////
var materialRadialMagnet = new MagnetRadialMaterial(10, 10);
// or var materialRadialMagnet = new MagnetRadialMaterial( QPointF(10, 10) );
// or var materialRadialMagnet = new MagnetRadialMaterial;
materialRadialMagnet.pos = QPointF(10, 10);
//materialRadialMagnet.x = 10;
//materialRadialMagnet.y = 10;
var pos = materialRadialMagnet.pos;

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

var center = materialRadialMagnet.center; // QPointF
materialRadialMagnet.center = center;

///////////////////////////////////////////////////////////////////////////////////////////////////////////////
// MagnetParallelMaterial
///////////////////////////////////////////////////////////////////////////////////////////////////////////////
var materialParallelMagnet = new MagnetParallelMaterial(10, 10);
// or var materialParallelMagnet = new MagnetParallelMaterial( QPointF(10, 10) );
// or var materialParallelMagnet = new MagnetParallelMaterial;
materialParallelMagnet.pos = QPointF(10, 10);
//materialParallelMagnet.x = 10;
//materialParallelMagnet.y = 10;
var pos = materialParallelMagnet.pos;

// for Magnetization.Parallel
materialParallelMagnet.angle = 15;
var angle = materialParallelMagnet.angle;

///////////////////////////////////////////////////////////////////////////////////////////////////////////////
// ConductorMaterial
///////////////////////////////////////////////////////////////////////////////////////////////////////////////
var materialConductor = new ConductorMaterial(10, 10);
// or var materialConductor = new ConductorMaterial( QPointF(10, 10) );
// or var materialConductor = new ConductorMaterial;
materialConductor.pos = QPointF(10, 10);
//materialConductor.x = 10;
//materialConductor.y = 10;
var pos = materialConductor.pos;



///////////////////////////////////////////////////////
// Geometry objects

///////////////////////////////////////////////////////
// Segment
// Отрезок , координаты начала задаются точкой p1, конца точкой p2
var segment = new Segment;
var segment = new Segment(x1, y1, x2, y2);
var segment = new Segment(p1, p2); // где p1 и p2 объекты типа QPointF

var p1 = segment.p1;
segment.p1 = p1; // где p1 объект типа QPointF
var p2 = segment.p2;
segment.p2 = p2; // где p2 объект типа QPointF

var x1 = segment.x1;
segment.x1 = x1;
var y1 = segment.y1;
segment.y1 = y1;

var x2 = segment.x2;
segment.x2 = x2;
var y2 = segment.y2;
segment.y2 = y2;

var len = segment.length; //длина линии
var a = segment.angle; //угол линии в градусах, относительно OX

var isSegment = segment.isSegment(); // для segment, isSegment равно true
var isArc = segment.isArc(); // для segment, isArc равно false

///////////////////////////////////////////////////////
// Arc
// где a1 и a2 начальный и конечный угол дуги в градусах, ноль на три часа, положительное направление против часовой стрелки
// с - центр дуги, объект типа QPointF
// cx и су - координаты центра
// r - радиус
var arc = new Arc;
var arc = new Arc(a1, a2, r, c);
var arc = new Arc(a1, a2, r, cx, cy);

var a1 = arc.angle1;
arc.angle1 = a1;
var a2 = arc.angle2;
arc.angle2 = a2

var r = arc.radius;
arc.radius = r;

var c = arc.center;
arc.center = c;

var cx = arc.centerX;
arc.centerX = cx;
var cy = arc.centerY;
arc.centerY = cy

var p1 = arc.p1; // координата начала дуги
var p2 = arc.p2; // координата конца дуги
var len = arc.length; //длина дуги

var isSegment = arc.isSegment(); // для Arc, issegment равно false
var isArc = arc.isArc(); // для Arc, isArc равно true

// сопряжение двух сегментов, радиус сопряжения
var g = couplingSegments(segment1, segment2, radius, {suppressWarning = true | false});
var g = couplingSegments(arc, segment, radius);
var g = couplingSegments(segment, arc, radius);

// g - массив сегментов
// g[0] - первый сегмент (segment или arc) с учетом сопряжения
// g[1] - второй сегмент (segment или arc) с учетом сопряжения
// g[2] - дуга сопряжения
// если сопряжение не возможно сделать то первый и сторой сегменты не изменяются, а дуга сопряжения пустая (angle1 = angle2 = radius = cx = cy = 0)
// дополнительный не обязательный аргумент: подавление предупреждения о невозможность выполнить сопряжение

