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; } }