protected override IEnumerator ProcessPayload(VisualPayload payload)
{
var filledGraph = VisualizerFactory.InstantiateFilledGraph();
filledGraph.Initialize(this, payload);
AssignStates(filledGraph);
var mainColor = MainColor.GetFirstValue(payload.Data);
foreach (var entry in EntryField.GetEntries(payload.Data))
{
filledGraph.AddPoint(ZAxis.GetValue(entry),
YAxis.GetValue(entry));
}
filledGraph.SetGraphData(
mainColor);
filledGraph.ApplyPoints();
var iterator = Router.TransmitAll(payload);
while (iterator.MoveNext())
{
yield return(null);
}
}
public override double Get(double x, double y, double z, double w, double u, double v) => Source.Get(
x + XAxis.Get(x, y, z, w, u, v),
y + YAxis.Get(x, y, z, w, u, v),
z + ZAxis.Get(x, y, z, w, u, v),
w + WAxis.Get(x, y, z, w, u, v),
u + UAxis.Get(x, y, z, w, u, v),
v + VAxis.Get(x, y, z, w, u, v));
//
// Summary:
// Check that all values in other are within epsilon of the values in this
//
// Parameters:
// other:
//
// epsilon:
public bool EpsilonEquals(Plane3D other, double epsilon)
{
return(Origin.EpsilonEquals(other.Origin, epsilon) &&
XAxis.EpsilonEquals(other.XAxis, epsilon) &&
YAxis.EpsilonEquals(other.YAxis, epsilon) &&
ZAxis.EpsilonEquals(other.ZAxis, epsilon));
}
protected void UpdateAxisLength(IATKDimension dimension)
{
switch (dimension)
{
case IATKDimension.X:
if (XAxis != null)
{
XAxis.UpdateLength(Scale.x);
}
break;
case IATKDimension.Y:
if (YAxis != null)
{
YAxis.UpdateLength(Scale.y);
}
break;
case IATKDimension.Z:
if (ZAxis != null)
{
ZAxis.UpdateLength(Scale.z);
}
break;
}
}
// This supports non-rectangular data, because the X and Z "grid coordinates" are stored in the payload itself
private void AssignElements(IEnumerable <MutableObject> mutables)
{
foreach (var element in mutables)
{
IsoGrid.AddEntry(XAxis.GetLastKeyValue(element), ZAxis.GetLastKeyValue(element), element);
}
}
public bool Equals([AllowNull] Scene other)
{
if (other == null)
{
return(false);
}
if (ReferenceEquals(this, other))
{
return(true);
}
return((BgColor == other.BgColor && BgColor != null && other.BgColor != null && BgColor.Equals(other.BgColor)) &&
(Camera == other.Camera && Camera != null && other.Camera != null && Camera.Equals(other.Camera)) &&
(Domain == other.Domain && Domain != null && other.Domain != null && Domain.Equals(other.Domain)) &&
(AspectMode == other.AspectMode && AspectMode != null && other.AspectMode != null && AspectMode.Equals(other.AspectMode)) &&
(AspectRatio == other.AspectRatio && AspectRatio != null && other.AspectRatio != null && AspectRatio.Equals(other.AspectRatio)) &&
(XAxis == other.XAxis && XAxis != null && other.XAxis != null && XAxis.Equals(other.XAxis)) &&
(YAxis == other.YAxis && YAxis != null && other.YAxis != null && YAxis.Equals(other.YAxis)) &&
(ZAxis == other.ZAxis && ZAxis != null && other.ZAxis != null && ZAxis.Equals(other.ZAxis)) &&
(DragMode == other.DragMode && DragMode != null && other.DragMode != null && DragMode.Equals(other.DragMode)) &&
(HoverMode == other.HoverMode && HoverMode != null && other.HoverMode != null && HoverMode.Equals(other.HoverMode)) &&
(UiRevision == other.UiRevision && UiRevision != null && other.UiRevision != null && UiRevision.Equals(other.UiRevision)) &&
(Equals(Annotations, other.Annotations) || Annotations != null && other.Annotations != null && Annotations.SequenceEqual(other.Annotations)));
}
public Point3d ProjectTo(Point3d point)
{
Vector3d origToPt = new Vector3d(Origin, point);
double angle = ZAxis.AngleTo(origToPt);
if (angle <= Math.PI / 2)
{
// Point is 'above' the plane
double alpha = Math.PI / 2 - angle;
double length = Math.Sin(alpha) * origToPt.Length;
Vector3d translate = ZAxis.Clone();
translate.Reverse();
translate.SetMagnitude(length);
Point3d pt = point + translate;
return(pt);
}
else
{
// Point is 'below' the plane
double alpha = Math.PI - angle;
double length = Math.Sin(alpha) * origToPt.Length;
Vector3d translate = ZAxis.Clone();
translate.SetMagnitude(length);
Point3d pt = point + translate;
return(pt);
}
}
//
// Summary:
// Transform the plane with a Transformation matrix.
//
// Parameters:
// xform:
// Transformation to apply to plane.
//
// Returns:
// true on success, false on failure.
public bool Transform(Transform3D xform)
{
Origin.Transform(xform);
XAxis.Transform(xform);
YAxis.Transform(xform);
ZAxis.Transform(xform);
return(true);
}
/// <summary>
/// Constructs the string representation of this plane.
/// </summary>
/// <returns>Text.</returns>
public override string ToString()
{
string rc = String.Format(System.Globalization.CultureInfo.InvariantCulture,
"Origin={0} XAxis={1}, YAxis={2}, ZAxis={3}",
Origin, XAxis, YAxis, ZAxis.ToString());
return(rc);
}
/// <inheritdoc />
/// <since>7.0</since>
public string ToString(string format, IFormatProvider formatProvider)
{
var fo = Origin.ToString(format, formatProvider);
var fx = XAxis.ToString(format, formatProvider);
var fy = YAxis.ToString(format, formatProvider);
var fz = ZAxis.ToString(format, formatProvider);
return($"Origin={fo} XAxis={fx}, YAxis={fy}, ZAxis={fz}");
}
protected override IEnumerator ProcessPayload(VisualPayload payload)
{
payload.VisualData.Bound.name = "Line Graph Bound";
var lineGraph = VisualizerFactory.InstantiateLineGraph();
lineGraph.Initialize(this, payload);
AssignStates(lineGraph);
var entries = EntryField.GetLastKeyValue(payload.Data) as IEnumerable <MutableObject>;
if (entries == null)
{
throw new Exception("Illegal mutable field here! " + EntryField.AbsoluteKey + " is not an enumerable of mutables!");
}
if (!entries.Any())
{
yield return(null);
yield break;
}
foreach (var entry in entries)
{
Vector3 entryPosition =
new Vector3(
XAxis.GetLastKeyValue(entry),
YAxis.GetLastKeyValue(entry),
ZAxis.GetLastKeyValue(entry)
);
Color pointColor = PointColor.GetLastKeyValue(entry);
lineGraph.AddPoint(entryPosition, pointColor);
yield return(null);
}
yield return(null);
lineGraph.SetLineData(MainColor.GetLastKeyValue(payload.Data),
LineWidth.GetLastKeyValue(payload.Data),
ZDepthOffset.GetLastKeyValue(payload.Data),
EdgeColor.GetLastKeyValue(payload.Data),
EdgeWidth.GetLastKeyValue(payload.Data),
PointWidth.GetLastKeyValue(payload.Data),
PulseLine.GetLastKeyValue(payload.Data),
PulseWidth.GetLastKeyValue(payload.Data),
Wipe.GetLastKeyValue(payload.Data),
StartTime.GetLastKeyValue(payload.Data),
WipeDuration.GetLastKeyValue(payload.Data)
);
lineGraph.ApplyPoints();
}
/// <inheritdoc />
public override int GetHashCode()
{
unchecked // Overflow is fine, just wrap
{
var hashCode = 41;
if (BgColor != null)
{
hashCode = hashCode * 59 + BgColor.GetHashCode();
}
if (Camera != null)
{
hashCode = hashCode * 59 + Camera.GetHashCode();
}
if (Domain != null)
{
hashCode = hashCode * 59 + Domain.GetHashCode();
}
if (AspectMode != null)
{
hashCode = hashCode * 59 + AspectMode.GetHashCode();
}
if (AspectRatio != null)
{
hashCode = hashCode * 59 + AspectRatio.GetHashCode();
}
if (XAxis != null)
{
hashCode = hashCode * 59 + XAxis.GetHashCode();
}
if (YAxis != null)
{
hashCode = hashCode * 59 + YAxis.GetHashCode();
}
if (ZAxis != null)
{
hashCode = hashCode * 59 + ZAxis.GetHashCode();
}
if (DragMode != null)
{
hashCode = hashCode * 59 + DragMode.GetHashCode();
}
if (HoverMode != null)
{
hashCode = hashCode * 59 + HoverMode.GetHashCode();
}
if (UiRevision != null)
{
hashCode = hashCode * 59 + UiRevision.GetHashCode();
}
if (Annotations != null)
{
hashCode = hashCode * 59 + Annotations.GetHashCode();
}
return(hashCode);
}
}
private void radioButtonBlue_CheckedChanged(object sender, System.EventArgs e)
{
if (radioButtonBlue.Checked)
{
zaxis = ZAxis.blue;
MakeBluePalette();
GetCoords();
pictureBox.Refresh();
}
}
private void radioButtonGreen_CheckedChanged(object sender, System.EventArgs e)
{
if (radioButtonGreen.Checked)
{
zaxis = ZAxis.green;
MakeGreenPalette();
GetCoords();
pictureBox.Refresh();
}
}
private void radioButtonRed_CheckedChanged(object sender, System.EventArgs e)
{
if (radioButtonRed.Checked)
{
zaxis = ZAxis.red;
MakeRedPalette();
GetCoords();
pictureBox.Refresh();
}
}
public bool Equals(MarkerEditViewModel other)
{
return(Name == other.Name &&
X.Equals(other.X) &&
Y.Equals(other.Y) &&
Z.Equals(other.Z) &&
XAxis.Equals(other.XAxis) &&
YAxis.Equals(other.YAxis) &&
ZAxis.Equals(other.ZAxis) &&
Actions.Equals(other.Actions) &&
Id == other.Id);
}
private void OnTimerTick(object sender, object e)
{
double x = 0;
double y = 0;
double z = 0;
if (measurement != null)
{
x = measurement.X;
y = measurement.Y;
z = measurement.Z;
}
else if (movement != null)
{
x = movement.MagX;
y = movement.MagY;
z = movement.MagZ;
}
double xAngle = x * (360 / 30);
AnimationHelper.BeginAnimation(XCompass, new DoubleAnimation()
{
Duration = new Duration(TimeSpan.FromMilliseconds(100)), To = xAngle, EnableDependentAnimation = true
}, "Angle", null);
double yAngle = y * (360 / 30);
AnimationHelper.BeginAnimation(YCompass, new DoubleAnimation()
{
Duration = new Duration(TimeSpan.FromMilliseconds(100)), To = yAngle, EnableDependentAnimation = true
}, "Angle", null);
double zAngle = z * (360 / 100);
AnimationHelper.BeginAnimation(ZCompass, new DoubleAnimation()
{
Duration = new Duration(TimeSpan.FromMilliseconds(100)), To = zAngle, EnableDependentAnimation = true
}, "Angle", null);
if (!animating)
{
animating = true;
XAxis.Start();
YAxis.Start();
ZAxis.Start();
}
XAxis.SetCurrentValue(x);
YAxis.SetCurrentValue(y);
ZAxis.SetCurrentValue(z);
}
void OnTimerTick(object sender, object e)
{
try
{
if (!animating)
{
animating = true;
XAxis.Start();
YAxis.Start();
ZAxis.Start();
}
double x = 0;
double y = 0;
double z = 0;
if (measurement != null)
{
x = measurement.X;
y = measurement.Y;
z = measurement.Z;
}
else if (movement != null)
{
x = movement.AccelX;
y = movement.AccelY;
z = movement.AccelZ;
}
XAxis.SetCurrentValue(x);
YAxis.SetCurrentValue(y);
ZAxis.SetCurrentValue(z);
int s = (int)Math.Max(1, GetSensitivity());
if (period.HasValue && s != period && !updatingPeriod)
{
updatingPeriod = true;
period = s;
Task.Run(new Action(UpdatePeriod));
}
double seconds = (double)watch.ElapsedMilliseconds / 1000.0;
double rate = msgCount / seconds;
MsgPerSec.Text = string.Format("{0:N0} m/s", rate);
}
catch (Exception)
{
}
}
protected override IEnumerator ProcessPayload(VisualPayload payload)
{
//payload.ClearBoundVisualizer();
var volume = VisualizerFactory.InstantiateRectangularVolume();
//payload.GetTargetBound().ChildWithinBound(volume.transform);
//.BoundedVisual = volume;
volume.Initialize(this, payload);
volume.SetOpaqueMaterial(UseOpaqueMaterial.GetFirstValue(payload.Data));
var xProportion = XAxis.GetFirstValue(payload.Data);
if (XMax.CouldResolve(payload.Data) && XMax.GetFirstValue(payload.Data) > .001f)
{
xProportion = xProportion / XMax.GetFirstValue(payload.Data);
}
var yProportion = YAxis.GetFirstValue(payload.Data);
if (YMax.CouldResolve(payload.Data) && YMax.GetFirstValue(payload.Data) > .001f)
{
yProportion = yProportion / YMax.GetFirstValue(payload.Data);
}
var zProportion = ZAxis.GetFirstValue(payload.Data);
if (ZMax.CouldResolve(payload.Data) && ZMax.GetFirstValue(payload.Data) > .001f)
{
zProportion = zProportion / ZMax.GetFirstValue(payload.Data);
}
volume.Xscale = xProportion;
volume.Yscale = yProportion;
volume.Zscale = zProportion;
volume.Color = Color.GetFirstValue(payload.Data);
var newPayload = new VisualPayload(payload.Data, new VisualDescription(volume.Bound));
var iterator = Router.TransmitAll(newPayload);
while (iterator.MoveNext())
{
yield return(null);
}
}
protected override IEnumerator ProcessPayload(VisualPayload payload)
{
Debug.LogWarning("[BOUND DEBUG] IsoGrid rendering to bound.", payload.VisualData.Bound);
IsoGrid = VisualizerFactory.InstantiateIsoGrid();
IsoGrid.Initialize(this, payload);
//payload.VisualData.Bound.ChildVisualizer(this, IsoGrid);
IsoGrid.DrawBackgrounds = ShowBackgrounds.GetLastKeyValue(payload.Data);
IsoGrid.InitializeIsoGrid(payload.VisualData.Bound);
IsoGrid.AllowSlicer = AllowSlicerField.GetLastKeyValue(payload.Data);
AssignStates(IsoGrid);
var entries = EntryField.GetFirstValue(payload.Data);
if (entries == null)
{
throw new Exception("Illegal mutable field here! " + EntryField.AbsoluteKey + " is not an enumerable of mutables!");
}
// Determine the full size of the entire isogrid
int numCellsXAxis = 0;
int numCellsZAxis = 0;
if (entries.Any())
{
numCellsXAxis = XAxis.GetEntries(payload.Data).Max(e => XAxis.GetValue(e)) + 1;
numCellsZAxis = ZAxis.GetEntries(payload.Data).Max(e => ZAxis.GetValue(e)) + 1;
}
IsoGrid.UpdateHorizontalScale(numCellsXAxis);
IsoGrid.UpdateDepthScale(numCellsZAxis);
AssignElements(entries);
var iterator = IsoGrid.Apply();
while (iterator.MoveNext( ))
{
yield return(null);
}
// PROCESS the label stuff, that was specified by the author:
LabelSystem.Render(payload, IsoGrid.transform, IsoGrid.SelectionManager);
}
public static DxfVector RightVectorFromNormal(DxfVector normal)
{
// compute a right (x-axis) vector from a given normal as per the Arbitrary Axis Algorithm
// http://help.autodesk.com/view/OARX/2020/ENU/?guid=GUID-E19E5B42-0CC7-4EBA-B29F-5E1D595149EE
var axisEpsilon = 1.0 / 64.0;
if (Math.Abs(normal.X) < axisEpsilon && Math.Abs(normal.Y) < axisEpsilon)
{
return(YAxis.Cross(normal));
}
else
{
return(ZAxis.Cross(normal));
}
}
public override int GetHashCode()
{
unchecked
{
var hashCode = (Name != null ? Name.GetHashCode() : 0);
hashCode = (hashCode * 397) ^ X.GetHashCode();
hashCode = (hashCode * 397) ^ Y.GetHashCode();
hashCode = (hashCode * 397) ^ Z.GetHashCode();
hashCode = (hashCode * 397) ^ XAxis.GetHashCode();
hashCode = (hashCode * 397) ^ YAxis.GetHashCode();
hashCode = (hashCode * 397) ^ ZAxis.GetHashCode();
hashCode = (hashCode * 397) ^ Actions.GetHashCode();
hashCode = (hashCode * 397) ^ (Id != null ? Id.GetHashCode() : 0);
return(hashCode);
}
}
void OnTimerTick(object sender, object e)
{
try
{
if (!animating)
{
animating = true;
XAxis.Start();
YAxis.Start();
ZAxis.Start();
}
double x = 0;
double y = 0;
double z = 0;
if (measurement != null)
{
x = measurement.X;
y = measurement.Y;
z = measurement.Z;
}
else if (movement != null)
{
x = movement.AccelX;
y = movement.AccelY;
z = movement.AccelZ;
}
XAxis.SetCurrentValue(x);
YAxis.SetCurrentValue(y);
ZAxis.SetCurrentValue(z);
int s = (int)Math.Max(1, GetSensitivity());
if (period.HasValue && s != period && !updatingPeriod)
{
updatingPeriod = true;
period = s;
Task.Run(new Action(UpdatePeriod));
}
}
catch (Exception)
{
}
}
/// <summary>
/// Returns a boolean indicating whether the given Plane is equal to this Plane instance.<br/>
/// The plane are equals if they have same origin and axises.
/// </summary>
/// <param name="other">The Plane to compare this instance to.</param>
/// <returns>True if the other Plane is equal to this instance; False otherwise.</returns>
public bool Equals(Plane other)
{
if (ReferenceEquals(null, other))
{
return(false);
}
if (ReferenceEquals(this, other))
{
return(false);
}
return(Origin.Equals(other.Origin) &&
XAxis.Equals(other.XAxis) &&
YAxis.Equals(other.YAxis) &&
ZAxis.Equals(other.ZAxis));
}
public Structural1DElement[] Explode()
{
var elements = new List <Structural1DElement>();
for (var i = 0; i < Value.Count() / 3 - 1; i++)
{
var element = new Structural1DElement(
Value.Skip(i * 3).Take(6).ToArray(),
ElementType,
PropertyRef,
ZAxis == null || ZAxis.Count() <= i ? null : ZAxis[i],
EndRelease == null || EndRelease.Count() < i * 2 + 2 ? null : EndRelease.Skip(i * 2).Take(2).ToArray(),
Offset == null || Offset.Count() < i * 2 + 2 ? null : Offset.Skip(i * 2).Take(2).ToArray(),
ElementApplicationId != null && ElementApplicationId.Count() > i ? ElementApplicationId[i] : ApplicationId + "_" + i.ToString()
);
element.GSADummy = GSADummy;
element.GSAMeshSize = GSAMeshSize;
elements.Add(element);
}
return(elements.ToArray());
}
protected override IEnumerator ProcessPayload(VisualPayload payload)
{
payload.VisualData.Bound.name = "Scatter Plot Bound";
var scatterPlot = VisualizerFactory.InstantiateScatterPlot();
scatterPlot.Initialize(this, payload);
AssignStates(scatterPlot);
var entries = EntryField.GetLastKeyValue(payload.Data) as IEnumerable <MutableObject>;
if (entries == null)
{
throw new Exception("Illegal mutable field here! " + EntryField.AbsoluteKey + " is not an enumerable of mutables!");
}
if (!entries.Any())
{
yield return(null);
yield break;
}
foreach (var entry in entries)
{
Vector3 entryPosition =
new Vector3(
XAxis.GetLastKeyValue(entry),
YAxis.GetLastKeyValue(entry),
ZAxis.GetLastKeyValue(entry)
);
scatterPlot.DrawPoint(entryPosition, entry);
}
scatterPlot.ApplyPoints();
}
public override double Get(double x, double y, double z, double w) => Source.Get(
x + XAxis.Get(x, y, z, w),
y + YAxis.Get(x, y, z, w),
z + ZAxis.Get(x, y, z, w),
w + WAxis.Get(x, y, z, w));
public override double Get(double x, double y, double z) => Source.Get(
x + XAxis.Get(x, y, z),
y + YAxis.Get(x, y, z),
z + ZAxis.Get(x, y, z));
/// <summary>
/// Returns the hash code for this instance.
/// </summary>
/// <returns>The hash code of the plane.</returns>
public override int GetHashCode()
{
return(Origin.GetHashCode() + ZAxis.GetHashCode());
}
void OnTimerTick(object sender, object e)
{
try
{
// gyro only gives reading every second, but we want to animate the rotation 30 times a second.
// we also have to flip X and Y coordinates to match the pretty picture on screen.
if (rx > MinimumMovement)
{
BorderProjection.RotationY += speedX;
rx -= speedX;
}
else if (rx < -MinimumMovement)
{
BorderProjection.RotationY -= speedX;
rx += speedX;
}
if (ry > MinimumMovement)
{
BorderProjection.RotationX += speedY;
ry -= speedY;
}
else if (ry < -MinimumMovement)
{
BorderProjection.RotationX -= speedY;
ry += speedY;
}
if (rz > MinimumMovement)
{
BorderProjection.RotationZ += speedZ;
rz -= speedZ;
}
else if (rz < -MinimumMovement)
{
BorderProjection.RotationZ -= speedZ;
rz += speedZ;
}
double x = 0;
double y = 0;
double z = 0;
if (measurement != null)
{
x = measurement.X;
y = measurement.Y;
z = measurement.Z;
}
else if (movement != null)
{
x = movement.GyroX;
y = movement.GyroY;
z = movement.GyroZ;
}
if (!animating)
{
animating = true;
XAxis.Start();
YAxis.Start();
ZAxis.Start();
}
XAxis.SetCurrentValue(ClampX(x));
YAxis.SetCurrentValue(ClampY(y));
ZAxis.SetCurrentValue(ClampZ(z));
}
catch (Exception)
{
}
}
