public void SetRangeAxisXMinutes(int min)
{
long ticks = min * 60000;
Axis2D axis = viewGraph.AxesX[0];
long curTicks = (long)(viewGraph.BufferedSeries.PointsCount * viewGraph.BaseTime);
viewGraph.Zooming.SetAllAxisXEnabledInStack(false);
if (ticks > curTicks)
{
axis.WholeRange.MaxValue = ticks;
axis.WholeRange.MinValue = 0;
axis.VisualRange.MaxValue = (double)axis.WholeRange.MaxValue;
axis.VisualRange.MinValue = 0;
}
else
{
axis.WholeRange.MaxValue = curTicks;
axis.WholeRange.MinValue = 0;
axis.VisualRange.MaxValue = curTicks;
axis.VisualRange.MinValue = curTicks - ticks;
}
}
public SerialBuilder ToMap2D(Axis2D axis)
{
var transformNode = new Map1DToMap2DNode(axis);
node.AddOutput("value", transformNode, "value");
return(new SerialBuilder(transformNode));
}
public override GameObject CreateAutoTickedAxis(string name, AxisDirection direction, DataSet data)
{
GameObject axis = Instantiate(Axis2DPrefab);
Axis2D axis2Dcomp = axis.GetComponent <Axis2D>();
switch (data.TypeOf(name))
{
case LoM.NOMINAL:
axis2Dcomp.Init(data.nominalStatistics[name], direction);
break;
case LoM.ORDINAL:
axis2Dcomp.Init(data.ordinalStatistics[name], direction);
break;
case LoM.INTERVAL:
axis2Dcomp.Init(data.intervalStatistics[name], direction);
break;
default: // RATIO
axis2Dcomp.Init(data.rationalStatistics[name], direction);
break;
}
return(axis);
}
public override GameObject CreateFixedLengthAutoTickedAxis(string name, float length, AxisDirection direction, DataSet data)
{
if (data.TypeOf(name) == LoM.INTERVAL || data.TypeOf(name) == LoM.RATIO)
{
return(CreateAutoTickedAxis(name, direction, data));
}
else
{
GameObject axis = Instantiate(Axis2DPrefab);
Axis2D axis2Dcomp = axis.GetComponent <Axis2D>();
switch (data.TypeOf(name))
{
case LoM.NOMINAL:
axis2Dcomp.Init(data.nominalStatistics[name], direction, true, length);
break;
case LoM.ORDINAL:
axis2Dcomp.Init(data.ordinalStatistics[name], direction, true, length);
break;
default:
axis = new GameObject("Creation Failed");
break;
}
return(axis);
}
}
internal void ErstelleFase(object[] ParameterListe)
{
bool GewindeFeature = Convert.ToBoolean(ParameterListe[10]);
bool GewindeHelix = Convert.ToBoolean(ParameterListe[11]);
myBody = hsp_catiaPart.Part.MainBody;
hsp_catiaPart.Part.InWorkObject = myBody;
if (GewindeHelix)
{
HybridShapeDirection HelixDir = HSF.AddNewDirectionByCoord(1, 0, 0);
Reference RefHelixDir = hsp_catiaPart.Part.CreateReferenceFromObject(HelixDir);
Groove myChamfer = SF.AddNewGroove(hsp_catiaProfil_Fase);
myChamfer.RevoluteAxis = RefHelixDir;
}
else
{
Groove grooveFase = SF.AddNewGroove(hsp_catiaProfil_Fase);
GeometricElements element1 = hsp_catiaProfil_Gewinde.GeometricElements;
Axis2D axis2D1 = (Axis2D)element1.Item("Absolute Achse");
Reference reference3 = (Reference)axis2D1.GetItem("V-Richtung");
grooveFase.RevoluteAxis = reference3;
}
hsp_catiaPart.Part.Update();
}
public Map1DToMap2DNode ToMap2D(Axis2D axis)
{
var transformNode = new Map1DToMap2DNode(axis);
AddOutput("value", transformNode, "value");
return(transformNode);
}
public override GameObject CreateAutoTickedAxis(string name, float max, AxisDirection dir = AxisDirection.Y)
{
GameObject axis = Instantiate(Axis2DPrefab);
Axis2D axis2Dcomp = axis.GetComponent <Axis2D>();
axis2Dcomp.Init(name, max, dir);
return(axis);
}
public void ResetRangeAxisX()
{
Axis2D axis = viewGraph.AxesX[0];
axis.WholeRange.MaxValue = xAxis.Minutes * 60000;
axis.WholeRange.MinValue = 0;
axis.VisualRange.MaxValue = xAxis.Minutes * 60000;
axis.VisualRange.MinValue = 0;
}
public static Rectangle <T>[] Subdivide <T>(this Rectangle <T> rect, Axis2D axis, IEnumerable <double> divisions) where T : INumeric <T>
{
return(rect[axis]
.Subdivide(divisions)
.Select(interval =>
axis == Axis2D.Horizontal
? Rectangle.FromIntervals(interval, rect.VerticalInterval)
: Rectangle.FromIntervals(rect.HorizontalInterval, interval))
.ToArray());
}
public void SetMaxRangeAxisX(double max)
{
MaxRangeAxisX = max;
Axis2D axis = viewGraph.AxesX[0];
viewGraph.VisualRangeChanging = true;
axis.WholeRange.SetMinMaxValues(0, max);
axis.VisualRange.SetMinMaxValues(0, max);
viewGraph.VisualRangeChanging = false;
}
internal static byte ParseControlID(Axis2D axis)
{
switch (axis)
{
case Axis2D.Position:
return((byte)AirVRTouchpadKey.ExtAxis2DPosition);
}
Assert.IsTrue(false);
return(0);
}
public static Vector2 ToVector2WithOne(this float value, Axis2D axis)
{
if (axis == Axis2D.X)
{
return(new Vector2(value, 1.0f));
}
else
{
return(new Vector2(1.0f, value));
}
}
private void chartControl1_BoundDataChanged(object sender, RoutedEventArgs e)
{
XYDiagram2D diagram = ((ChartControl)sender).Diagram as XYDiagram2D;
Axis2D axisY = diagram.ActualAxisY;
axisY.VisualRange = new Range();
double minValue = diagram.Series.Select(s => s.Points.Min(p => p.Value)).Min() * 1.1;
double maxValue = diagram.Series.Select(s => s.Points.Max(p => p.Value)).Max() * 1.1;
axisY.VisualRange.SetMinMaxValues(minValue, maxValue);
}
/// <summary>
/// Set all relevant properties concerning side margins with a single function call.
/// </summary>
/// <param name="axis"></param>
/// <param name="sideMarginsEnabled">Enabled or disables auto side margins. If false, sideMarginsValue will always be set to 0.</param>
public static void SetSideMarginsEnabled(this Axis2D axis, bool sideMarginsEnabled)
{
double?margin = null;
if (axis.Logarithmic)
{
margin = 0.7; // in order to show a major tick with label below the min value for a log scaled axis
}
axis.WholeRange.SetSideMarginsEnabled(sideMarginsEnabled, margin);
axis.VisualRange.SetSideMarginsEnabled(sideMarginsEnabled, margin);
}
public DeviceMap_Axis2D CreateAxis2DMap(DeviceMapConfig_Axis2D config, Axis2D axis)
{
var result = new DeviceMap_Axis2D();
result.invertAxisX = config.invertAxisX;
result.invertAxisY = config.invertAxisY;
result.axisX_Src = axes1D_backing[config.axis1D_X_Src];
result.axisY_Src = axes1D_backing[config.axis1D_Y_Src];
result.axisDst = axis;
return(result);
}
/// <summary>
/// Searches for Joystick config name. (returns null if not found)
/// </summary>
/// <param name="joystick">Joystick part of this Gamepad</param>
/// <returns>Joystick name</returns>
public string GetJoystickName(Axis2D joystick)
{
foreach (var map in joystickNameMaps)
{
if (map.axis == joystick)
{
return(map.name);
}
}
return(null);
}
public static Vector2 ToVector2With(this float firstValue, Axis2D firsValueAxis, float secondValue)
{
if (firsValueAxis == Axis2D.X)
{
return(new Vector2(firstValue, secondValue));
}
else
{
return(new Vector2(secondValue, firstValue));
}
}
private void initializeAxis(Axis2D axis, AxisData axisData)
{
axis.Title.Text = axisData.Caption;
axis.Title.Alignment = StringAlignment.Center;
axis.Title.Visibility = DefaultBoolean.True;
axis.Alignment = AxisAlignment.Near;
axis.GridLines.Visible = true;
axis.WholeRange.Auto = true;
axis.WholeRange.AlwaysShowZeroLevel = false;
axis.Logarithmic = (axisData.Scaling == Scalings.Log);
axis.MinorCount = axis.Logarithmic ? DEFAULT_TICKS_FOR_LOG_SCALE : DEFAULT_TICKS_FOR_LIN_SCALE;
}
//============================================================
public static Vector2 MixWith(this Vector2 self, Axis2D axis, Vector2 other)
{
if ((axis & Axis2D.X) != 0)
{
self.x = other.x;
}
if ((axis & Axis2D.Y) != 0)
{
self.y = other.y;
}
return(self);
}
/// <summary>
/// mvvm action
/// </summary>
/// <param name="json"></param>
protected override void doAction(string json = "")
{
base.doAction();
Axis2D ax = null;
//ax = ((SwiftPlotDiagram)ccUltravioletDebug.Diagram).AxisX;
//ax.ConstantLines[1].AxisValue = int.Parse(ax.ConstantLines[0].AxisValue.ToString()) + (int.Parse(ax.ConstantLines[2].AxisValue.ToString()) - int.Parse(ax.ConstantLines[0].AxisValue.ToString())) / 2;
//ax.ConstantLines[4].AxisValue = int.Parse(ax.ConstantLines[3].AxisValue.ToString()) + (int.Parse(ax.ConstantLines[5].AxisValue.ToString()) - int.Parse(ax.ConstantLines[3].AxisValue.ToString())) / 2;
ax = ((SwiftPlotDiagram)ccInfraredDebug.Diagram).AxisX;
ax.ConstantLines[1].AxisValue = int.Parse(ax.ConstantLines[0].AxisValue.ToString()) + (int.Parse(ax.ConstantLines[2].AxisValue.ToString()) - int.Parse(ax.ConstantLines[0].AxisValue.ToString())) / 2;
ax.ConstantLines[4].AxisValue = int.Parse(ax.ConstantLines[3].AxisValue.ToString()) + (int.Parse(ax.ConstantLines[5].AxisValue.ToString()) - int.Parse(ax.ConstantLines[3].AxisValue.ToString())) / 2;
}
internal static byte ParseControlID(Axis2D axis)
{
switch (axis)
{
case Axis2D.LThumbstick:
return((byte)AirVRGamepadKey.Axis2DLThumbstick);
case Axis2D.RThumbstick:
return((byte)AirVRGamepadKey.Axis2DRThumbstick);
}
Assert.IsTrue(false);
return(0);
}
public static Vector2 Get(AirXRCameraRig cameraRig, Axis2D axis)
{
switch (axis)
{
case Axis2D.LThumbstick:
return(cameraRig.inputStream.GetAxis2D((byte)AXRInputDeviceID.Controller, (byte)AXRControllerControl.Axis2DLThumbstick));
case Axis2D.RThumbstick:
return(cameraRig.inputStream.GetAxis2D((byte)AXRInputDeviceID.Controller, (byte)AXRControllerControl.Axis2DRThumbstick));
default:
return(Vector2.zero);
}
}
public override GameObject CreateAxis(Color color, string variableName, string variableEntity,
AxisDirection axisDirection, float length, float width = 0.01F, bool tipped = true, bool ticked = false)
{
GameObject axis = Instantiate(Axis2DPrefab);
Axis2D axis2Dcomp = axis.GetComponent <Axis2D>();
axis2Dcomp.Init(new AttributeStats(LoM.RATIO, variableName));
axis2Dcomp.diameter = width;
axis2Dcomp.color = color;
axis2Dcomp.labelVariableText = variableName;
axis2Dcomp.tipped = tipped;
axis2Dcomp.length = length;
axis2Dcomp.ticked = ticked;
axis2Dcomp.UpdateAxis();
return(axis);
}
public override void _Ready()
{
values = new List <Vector2>();
min = new Vector2(float.PositiveInfinity, float.PositiveInfinity);
max = new Vector2(float.NegativeInfinity, float.NegativeInfinity);
xAxis = GetNode("XAxis2D") as Axis2D;
yAxis = GetNode("YAxis2D") as Axis2D;
title = GetNode("Title") as Label;
points = GetNode("Points") as Control;
legend = GetNode("Legend") as Legend;
xAxis.dir = Axis2D.DIR.X;
yAxis.dir = Axis2D.DIR.Y;
Resize();
Connect("resized", this, nameof(Resize));
}
/// <summary>
/// 计算区间最大最小值
/// </summary>
private void calcMax()
{
if (CalibrationViewModel.VM.AbsortHarmonicData.InfraredSpectrum != null)
{
double max = 0;
double min = 0;
double max1 = 0;
double min1 = 0;
Axis2D ax = ((SwiftPlotDiagram)ccInfrared.Diagram).AxisX;
int s = int.Parse(ax.ConstantLines[0].AxisValue.ToString());
int e = int.Parse(ax.ConstantLines[2].AxisValue.ToString());
int s1 = int.Parse(ax.ConstantLines[3].AxisValue.ToString());
int e1 = int.Parse(ax.ConstantLines[5].AxisValue.ToString());
double[] ps = CalibrationViewModel.VM.AbsortHarmonicData.InfraredSpectrum;
for (int i = 0; i < ps.Length; i++)
{
if (i > s && i < e)
{
if (max < ps[i])
{
max = ps[i];
}
if (min > ps[i])
{
min = ps[i];
}
}
if (i > s1 && i < e1)
{
if (max1 < ps[i])
{
max1 = ps[i];
}
if (min1 > ps[i])
{
min1 = ps[i];
}
}
}
ax.ConstantLines[0].Title.Text = (max - min).ToString("f2");
ax.ConstantLines[3].Title.Text = (max1 - min1).ToString("f2");
}
}
public static IControl Create(Axis2D axis, Brush brush)
{
var four = Observable.Return <Points>(3);
var two = Observable.Return <Points>(1);
var gentle = Observable.Return(new CornerRadius(1));
return(Layout
.Stack(
axis == Axis2D.Horizontal ? Direction2D.LeftToRight : Direction2D.TopToBottom,
Shapes.Rectangle(fill: brush, cornerRadius: gentle).WithDimension(axis, four),
Control.Empty.WithDimension(axis, two),
Shapes.Rectangle(fill: brush, cornerRadius: gentle).WithDimension(axis, four),
Control.Empty.WithDimension(axis, two),
Shapes.Rectangle(fill: brush, cornerRadius: gentle).WithDimension(axis, four))
.WithDimension(axis.Opposite(), Observable.Return <Points>(12))
.Center()
.WithSize(new Size <Points>(12, 16))
);
}
public void SetRangeAxisXTicks(long ticks)
{
if (viewGraph.Zooming.PointEnabled == true)
{
return;
}
Axis2D axis = viewGraph.AxesX[0];
double diff = (double)axis.WholeRange.MaxValue - (double)axis.VisualRange.MaxValue;
double visualWidth = (double)axis.VisualRange.MaxValue - (double)axis.VisualRange.MinValue;
if (ticks > (double)axis.WholeRange.MaxValue)
{
axis.WholeRange.MaxValue = ticks;
axis.WholeRange.MinValue = 0;
axis.VisualRange.MaxValue = (double)axis.WholeRange.MaxValue - diff;
axis.VisualRange.MinValue = (((double)axis.VisualRange.MaxValue - visualWidth) < 0) ? 0 : ((double)axis.VisualRange.MaxValue - visualWidth);
}
}
/// <summary>
/// mvvm action
/// </summary>
/// <param name="json"></param>
protected override void doAction(string json = "")
{
base.doAction();
Axis2D ax = ((SwiftPlotDiagram)ccUltravioletSpectrum.Diagram).AxisX;
ax.ConstantLines[1].AxisValue = int.Parse(ax.ConstantLines[0].AxisValue.ToString()) + (int.Parse(ax.ConstantLines[2].AxisValue.ToString()) - int.Parse(ax.ConstantLines[0].AxisValue.ToString())) / 2;
ax.ConstantLines[4].AxisValue = int.Parse(ax.ConstantLines[3].AxisValue.ToString()) + (int.Parse(ax.ConstantLines[5].AxisValue.ToString()) - int.Parse(ax.ConstantLines[3].AxisValue.ToString())) / 2;
ax = ((SwiftPlotDiagram)ccInfraredSpectrum.Diagram).AxisX;
ax.ConstantLines[1].AxisValue = int.Parse(ax.ConstantLines[0].AxisValue.ToString()) + (int.Parse(ax.ConstantLines[2].AxisValue.ToString()) - int.Parse(ax.ConstantLines[0].AxisValue.ToString())) / 2;
ax.ConstantLines[4].AxisValue = int.Parse(ax.ConstantLines[3].AxisValue.ToString()) + (int.Parse(ax.ConstantLines[5].AxisValue.ToString()) - int.Parse(ax.ConstantLines[3].AxisValue.ToString())) / 2;
((SwiftPlotDiagram)ccUltravioletSpectrum.Diagram).AxisX.ConstantLines[0].Color = Color.FromArgb(192, 0, 0);
((SwiftPlotDiagram)ccUltravioletSpectrum.Diagram).AxisX.ConstantLines[2].Color = Color.FromArgb(192, 0, 0);
((SwiftPlotDiagram)ccUltravioletSpectrum.Diagram).AxisX.ConstantLines[3].Color = Color.FromArgb(79, 97, 40);
((SwiftPlotDiagram)ccUltravioletSpectrum.Diagram).AxisX.ConstantLines[5].Color = Color.FromArgb(79, 97, 40);
((SwiftPlotDiagram)ccInfraredSpectrum.Diagram).AxisX.ConstantLines[0].Color = Color.FromArgb(192, 0, 0);
((SwiftPlotDiagram)ccInfraredSpectrum.Diagram).AxisX.ConstantLines[2].Color = Color.FromArgb(192, 0, 0);
((SwiftPlotDiagram)ccInfraredSpectrum.Diagram).AxisX.ConstantLines[3].Color = Color.FromArgb(79, 97, 40);
((SwiftPlotDiagram)ccInfraredSpectrum.Diagram).AxisX.ConstantLines[5].Color = Color.FromArgb(79, 97, 40);
}
private static void SetOffset(Vector2 offset, Axis2D axis, ProBuilderMesh[] sel)
{
UndoUtility.RecordSelection(sel, "Offset UVs");
for (int i = 0; i < sel.Length; i++)
{
foreach (Face q in sel[i].GetSelectedFaces())
{
switch (axis)
{
case Axis2D.XY:
{
var uv = q.uv;
uv.offset = offset;
q.uv = uv;
break;
}
case Axis2D.X:
{
var uv = q.uv;
uv.offset = new Vector2(offset.x, q.uv.offset.y);
q.uv = uv;
break;
}
case Axis2D.Y:
{
var uv = q.uv;
uv.offset = new Vector2(q.uv.offset.x, offset.y);
q.uv = uv;
break;
}
}
sel[i].SetGroupUV(q.uv, q.textureGroup);
}
}
}
private static void SetScale(Vector2 scale, Axis2D axis, ProBuilderMesh[] sel)
{
UndoUtility.RecordSelection(sel, "Scale UVs");
for (int i = 0; i < sel.Length; i++)
{
foreach (Face q in sel[i].GetSelectedFaces())
{
switch (axis)
{
case Axis2D.XY:
{
var uv = q.uv;
uv.scale = scale;
q.uv = uv;
break;
}
case Axis2D.X:
{
var uv = q.uv;
uv.scale = new Vector2(scale.x, q.uv.scale.y);
q.uv = uv;
break;
}
case Axis2D.Y:
{
var uv = q.uv;
uv.scale = new Vector2(q.uv.scale.x, scale.y);
q.uv = uv;
break;
}
}
sel[i].SetGroupUV(q.uv, q.textureGroup);
}
}
}
private static Vector2 GetResolvedAxis2D(Axis2D virtualMask, RawAxis2D rawMask, Controller controllerMask)
{
Vector2 maxAxis = Vector2.zero;
if ((controllerMask & Controller.Active) != 0)
controllerMask |= activeControllerType;
for (int i = 0; i < controllers.Count; i++)
{
OVRControllerBase controller = controllers[i];
if (ShouldResolveController(controller.controllerType, controllerMask))
{
RawAxis2D resolvedMask = rawMask | controller.ResolveToRawMask(virtualMask);
if ((RawAxis2D.LThumbstick & resolvedMask) != 0)
{
Vector2 axis = new Vector2(
controller.currentState.LThumbstick.x,
controller.currentState.LThumbstick.y);
maxAxis = CalculateAbsMax(maxAxis, axis);
}
if ((RawAxis2D.RThumbstick & resolvedMask) != 0)
{
Vector2 axis = new Vector2(
controller.currentState.RThumbstick.x,
controller.currentState.RThumbstick.y);
maxAxis = CalculateAbsMax(maxAxis, axis);
}
}
}
maxAxis = CalculateDeadzone(maxAxis, AXIS_DEADZONE_THRESHOLD);
return maxAxis;
}
/// <summary>
/// Gets the current state of the given virtual 2-dimensional axis mask on the given controller mask.
/// Returns the vector of the largest masked axis across all masked controllers. Values range from -1 to 1.
/// </summary>
public static Vector2 Get(Axis2D virtualMask, Controller controllerMask = Controller.Active)
{
return GetResolvedAxis2D(virtualMask, RawAxis2D.None, controllerMask);
}
public RawAxis2D ResolveToRawMask(Axis2D virtualMask)
{
return axis2DMap.ToRawMask(virtualMask);
}
public RawAxis2D ToRawMask(Axis2D virtualMask)
{
RawAxis2D rawMask = 0;
if (virtualMask == Axis2D.None)
return RawAxis2D.None;
if ((virtualMask & Axis2D.PrimaryThumbstick) != 0)
rawMask |= PrimaryThumbstick;
if ((virtualMask & Axis2D.SecondaryThumbstick) != 0)
rawMask |= SecondaryThumbstick;
return rawMask;
}
private Vector2 GetResolvedAxis2D(Axis2D virtualMask, RawAxis2D rawMask, ControllerType controllerMask)
{
if (!OVRManager.instance.isVRPresent)
return Vector2.zero;
Vector2 maxAxis = Vector2.zero;
if ((controllerMask & ControllerType.Active) != 0)
controllerMask |= activeControllerType;
for (int i = 0; i < controllers.Count; i++)
{
OVRControllerBase controller = controllers[i];
RawAxis2D resolvedMask = rawMask | controller.ResolveToRawMask(virtualMask);
if (ShouldResolveController(controller.controllerType, controllerMask))
{
if ((RawAxis2D.LThumbstick & resolvedMask) != 0)
{
Vector2 axis = new Vector2(
controller.currentInputState.LThumbstick.x,
controller.currentInputState.LThumbstick.y);
maxAxis = CalculateMax(maxAxis, axis);
}
if ((RawAxis2D.RThumbstick & resolvedMask) != 0)
{
Vector2 axis = new Vector2(
controller.currentInputState.RThumbstick.x,
controller.currentInputState.RThumbstick.y);
maxAxis = CalculateMax(maxAxis, axis);
}
}
}
return maxAxis;
}
/// <summary>
/// Gets the current state of the given virtual 2-dimensional axis mask on the given controller mask.
/// Returns the vector of the largest masked axis across all masked controllers. Values range from -1 to 1.
/// </summary>
public static Vector2 Get(Axis2D virtualMask, ControllerType controllerMask)
{
return OVRManager.input.GetResolvedAxis2D(virtualMask, RawAxis2D.None, controllerMask);
}
/// <summary>
/// Gets the current state of the given virtual 2-dimensional axis mask on the given controller mask.
/// Returns the vector of the largest masked axis across all masked controllers. Values range from -1 to 1.
/// </summary>
public static Vector2 Get(Axis2D virtualMask, Controller controllerMask = Controller.Active)
{
if (OVRManager.isHmdPresent)
{
return OVRManager.input.GetResolvedAxis2D(virtualMask, RawAxis2D.None, controllerMask);
} else
{
return Vector2.zero;
}
}
