private void setSeriesValues(CurveData <ScatterXValue, ScatterYValue> series, DataRow row, string yFieldName) { // find row with yField / data for y-Values var pkValues = row.GetPrimaryKeyValues(); pkValues[0] = yFieldName; DataRow yFieldRow = _data.Rows.Find(pkValues); var xValues = (float[])row[_aggregationName]; var yValues = (float[])yFieldRow[_aggregationName]; if (xValues.Length != yValues.Length) { throw new InvalidDataException(PKSimConstants.Error.DifferentVectorLengths); } for (int i = 0; i < xValues.Length; i++) { var scatterValue = new ScatterYValue(yValues[i]); if (scatterValue.IsValid) { series.Add(new ScatterXValue(xValues[i]), scatterValue); } } }
public void SetCurveAddress(CurveData data) { curveData = data; process = 0; offset = 0; angle = 0; }
public void ToCurveAddress(CurveData data, Action action = null) { if (data != null && data != curveData) { manaul = false; inTransition = true; transitionCurve = data; nearPosition = target.position; nearDirection = directionCurve.Evaluate((process / positionCurve.length) * directionCurve.length + offset); float minDis = float.MaxValue; float length = 0; toProcess = 0; for (int i = 0; i < data.position.smoothCount - 1; i++) { length += Vector3.Distance(data.position.GetSmoothPoint(i), data.position.GetSmoothPoint(i + 1)); float distance = Vector3.Distance(nearPosition, data.position.GetSmoothPoint(i)); if (distance < minDis) { minDis = distance; toProcess = length; } } toPosition = data.position.Evaluate(toProcess); toDirection = data.direction.Evaluate(toProcess / data.position.length * data.direction.length); toEndAction = action; StartCoroutine(InTransition()); } }
private IEnumerable <DataRow> addSpecificChartValues <TX, TY>(DataRow row, CurveData <TX, TY> curveData, bool exportForPivot) where TX : TimeProfileXValue where TY : ITimeProfileYValue { var newRows = new List <DataRow>(); for (var i = 0; i < curveData.XValues.Count; i++) { var newRow = row.Table.NewRow(); newRow.ItemArray = row.ItemArray; var xValue = ValueForDataTableFor(curveData.XAxis, curveData.XValues[i].X); if (exportForPivot) { newRow[_xValueColumn] = xValue.ConvertedTo <string>(); } else { newRow[_xValueColumn] = xValue; } newRow[_yLowerValueColumn] = ValueForDataTableFor(curveData.YAxis, curveData.YValues[i].LowerValue); newRow[_yValueColumn] = ValueForDataTableFor(curveData.YAxis, curveData.YValues[i].Y); newRow[_yUpperValueColumn] = ValueForDataTableFor(curveData.YAxis, curveData.YValues[i].UpperValue); newRows.Add(newRow); } return(newRows); }
private void RemoveSelected() { bool flag = false; List <CurveSelection> selectedCurves = this.m_CurveEditor.selectedCurves; for (int i = 0; i < selectedCurves.Count; i++) { int curveID = selectedCurves[i].curveID; for (int j = 0; j < this.m_AddedCurves.Count; j++) { CurveData data = this.m_AddedCurves[j]; if ((data.m_MaxId == curveID) || (data.m_MinId == curveID)) { flag |= this.Remove(j); break; } } } if (flag) { this.ContentChanged(); this.UpdateRangeBasedOnShownCurves(); } this.m_CurveEditor.SelectNone(); }
private List <CurveData> MergeCachedAndRealTimesCurves(List <CurveData> cache, List <CurveData> realtime) { List <CurveData> list = new List <CurveData>(); Dictionary <string, CurveData> dictionary = new Dictionary <string, CurveData>(); Dictionary <string, CurveData> dictionary2 = new Dictionary <string, CurveData>(); foreach (CurveData data in realtime) { dictionary[data.Key] = data; } foreach (CurveData data in cache) { dictionary2[data.Key] = data; if (dictionary.ContainsKey(data.Key)) { CurveData data2 = dictionary[data.Key]; data.Points.AddRange(data2.Points); } list.Add(data); } foreach (CurveData data in realtime) { if (!dictionary2.ContainsKey(data.Key)) { list.Add(data); } } return(list); }
protected override void SetCurveSettings(CurveData <TimeProfileXValue, TimeProfileYValue> series, DataRow row) { var outputField = _analysis.FieldByName(row[_dataColumnName].ToString()).DowncastTo <PopulationAnalysisOutputField>(); series.Color = outputField.Color; var statisticalAggregation = row[STATISTICAL_AGGREGATION].DowncastTo <StatisticalAggregation>(); series.LineStyle = statisticalAggregation.LineStyle; var colorField = _analysis.ColorField; if (colorField == null) { return; } var groupitem = colorField.GroupingByName(row[colorField.Name].ToString()); if (groupitem == null) { return; } series.Color = groupitem.Color; }
IEnumerator InTransition() { float nowTime = 0; float value = 0; while (nowTime <= toTime) { value = nowTime / toTime; target.position = Vector3.Lerp(nearPosition, toPosition, value * value); target.LookAt(Vector3.Lerp(nearDirection, toDirection, value), Vector3.up); nowTime += Time.deltaTime; yield return(new WaitForEndOfFrame()); } offset = 0; angle = 0; process = toProcess; curveData = transitionCurve; inTransition = false; manaul = true; if (toEndAction != null) { Action action = toEndAction; action.Invoke(); toEndAction = null; } }
private void RemoveSelected() { bool anyRemoved = false; List <CurveSelection> selection = m_CurveEditor.selectedCurves; for (int i = 0; i < selection.Count; ++i) { int curveId = selection[i].curveID; for (int j = 0; j < m_AddedCurves.Count; ++j) { CurveData cd = m_AddedCurves[j]; if (cd.m_MaxId == curveId || cd.m_MinId == curveId) { anyRemoved |= Remove(j); break; } } } if (anyRemoved) { ContentChanged(); UpdateRangeBasedOnShownCurves(); } m_CurveEditor.SelectNone(); }
protected override IReadOnlyList <Series> CreateCurveSeriesList(CurveData <ScatterXValue, ScatterYValue> curveData) { var series = CreateSeries(curveData, ViewType.Point) .WithPoints(CreateSeriesPoints(curveData, y => y.Value)); return(new[] { series }); }
private void SetTopMostCurve(DoubleCurve doubleCurve) { int num; if (this.m_CurveEditor.GetTopMostCurveID(out num)) { for (int i = 0; i < this.m_AddedCurves.Count; i++) { CurveData data = this.m_AddedCurves[i]; if ((data.m_MaxId == num) || (data.m_MinId == num)) { if (doubleCurve.signedRange == data.m_SignedRange) { if (data.m_MaxId > 0) { this.SetCurve(this.m_CurveEditor.GetCurveFromID(data.m_MaxId), doubleCurve.maxCurve); } if (data.m_MinId > 0) { this.SetCurve(this.m_CurveEditor.GetCurveFromID(data.m_MinId), doubleCurve.minCurve); } } else { Debug.LogWarning("Cannot assign a curves with different signed range"); } } } } }
private CurveWrapper[] CreateCurveWrapperArray() { List<CurveWrapper> list = new List<CurveWrapper>(); int num = 0; for (int i = 0; i < this.m_AddedCurves.Count; i++) { CurveData data = this.m_AddedCurves[i]; if (data.m_Visible) { int regionId = -1; if (data.IsRegion()) { regionId = ++num; } if (data.m_Max != null) { list.Add(this.CreateCurveWrapper(data.m_Max, data.m_MaxId, regionId, data.m_Color, data.m_SignedRange, data.m_GetAxisScalarsCallback, data.m_SetAxisScalarsCallback)); } if (data.m_Min != null) { list.Add(this.CreateCurveWrapper(data.m_Min, data.m_MinId, regionId, data.m_Color, data.m_SignedRange, data.m_GetAxisScalarsCallback, data.m_SetAxisScalarsCallback)); } } } return list.ToArray(); }
private DoubleCurve CreateDoubleCurveFromTopMostCurve() { int num; if (this.m_CurveEditor.GetTopMostCurveID(out num)) { for (int i = 0; i < this.m_AddedCurves.Count; i++) { CurveData data = this.m_AddedCurves[i]; if ((data.m_MaxId == num) || (data.m_MinId == num)) { AnimationCurve maxCurve = null; AnimationCurve minCurve = null; if (data.m_Min != null) { minCurve = data.m_Min.animationCurveValue; } if (data.m_Max != null) { maxCurve = data.m_Max.animationCurveValue; } return new DoubleCurve(minCurve, maxCurve, data.m_SignedRange); } } } return null; }
DoubleCurve CreateDoubleCurveFromTopMostCurve() { int topMostCurveID; if (m_CurveEditor.GetTopMostCurveID(out topMostCurveID)) { for (int j = 0; j < m_AddedCurves.Count; ++j) { CurveData cd = m_AddedCurves[j]; if (cd.m_MaxId == topMostCurveID || cd.m_MinId == topMostCurveID) { AnimationCurve maxCurve = null, minCurve = null; if (cd.m_Min != null) { minCurve = cd.m_Min.animationCurveValue; } if (cd.m_Max != null) { maxCurve = cd.m_Max.animationCurveValue; } return(new DoubleCurve(minCurve, maxCurve, cd.m_SignedRange)); } } } return(null); }
public static CurveData <BoxWhiskerXValue, BoxWhiskerYValue> CreateBoxWhiskerCurveData(PaneData <BoxWhiskerXValue, BoxWhiskerYValue> paneData, string name, IList <BoxWhiskerXYValue> bwValues) { var curveData = new CurveData <BoxWhiskerXValue, BoxWhiskerYValue>(new Dictionary <string, string> { { name, name } }) { Id = name, Caption = name }; foreach (var v in bwValues) { var X = new BoxWhiskerXValue(new List <string>() { v.X1, v.X2 }); var Y = new BoxWhiskerYValue { LowerWhisker = new ValueWithIndvividualId(v.LW), LowerBox = new ValueWithIndvividualId(v.LW), Median = new ValueWithIndvividualId(v.M), UpperBox = new ValueWithIndvividualId(v.LW), UpperWhisker = new ValueWithIndvividualId(v.LW), }; curveData.Add(X, Y); } return(curveData); }
public void Save() { BinaryFormatter bf = new BinaryFormatter(); FileStream file = File.Create(Application.dataPath + "/ProceduralTracks/CurvesSavedData/" + gameObject.name + transform.parent.GetComponent <Track>().id + ".curve"); CurveData data = new CurveData(); List <NodeData> _nodesData = new List <NodeData>(); if (nodes != null) { foreach (Node n in nodes) { _nodesData.Add(n.Serialize()); } } data.nodesData = _nodesData.ToArray(); List <BezierData> _splinesData = new List <BezierData>(); foreach (BezierSpline b in splines) { _splinesData.Add(b.GetData()); } data.splinesData = _splinesData.ToArray(); data.closed = this.closed; data.invisible = this.invisible; bf.Serialize(file, data); file.Close(); }
void ConvertCamera(UsdCamera cam, string path) { if (cam == null) { return; } var tcam = typeof(Camera); var cvs = new CurveData[] { new CurveData(tcam, path, "near clip plane", epsilon_Camera), new CurveData(tcam, path, "far clip plane", epsilon_Camera), new CurveData(tcam, path, "field of view", epsilon_Camera), }; usdi.usdiCameraEachSample(cam.nativeCameraPtr, (ref usdi.CameraData data, double t_) => { float t = (float)t_ * m_rcpTimeScale; cvs[0].curve.AddKey(t, data.near_clipping_plane); cvs[1].curve.AddKey(t, data.far_clipping_plane); cvs[2].curve.AddKey(t, data.field_of_view); }); if (m_keyframeReduction) { foreach (var c in cvs) { DoReduction(c); } } foreach (var c in cvs) { c.Set(m_animClip); } }
private void setCurveDataValues(CurveData <RangeXValue, RangeYValue> series, DataRow xFieldRow, string yFieldName) { // find row with yField / data for y-Values var pkValues = xFieldRow.GetPrimaryKeyValues(); pkValues[0] = yFieldName; // DATA_FIELD-column first, see CreatePrimaryKey DataRow yFieldRow = _data.Rows.Find(pkValues); var xValues = xFieldRow[_aggreationName] as float[]; var yValues = yFieldRow[_aggreationName] as float[]; //possible if no values are defined for the row filter if (xValues == null || yValues == null) { return; } if (xValues.Length != yValues.Length) { throw new InvalidDataException(PKSimConstants.Error.DifferentVectorLengths); } // create range curve on grid. Do not allow uniform interval distribution as data might be misleading var xValueIntervals = _binIntervalsCreator.CreateIntervalsFor(xValues.ToDoubleArray()); foreach (var xValueInterval in xValueIntervals) { var yValuesForXInterval = yValues.Where((y, i) => xValueInterval.Contains(xValues[i])).ToList(); var rangeYValue = createRangeYValue(yValuesForXInterval); if (rangeYValue.IsValid) { series.Add(createRangeXValue(xValueInterval, yValuesForXInterval.Count), rangeYValue); } } }
void SetTopMostCurve(DoubleCurve doubleCurve) { int topMostCurveID; if (m_CurveEditor.GetTopMostCurveID(out topMostCurveID)) { for (int j = 0; j < m_AddedCurves.Count; ++j) { CurveData cd = m_AddedCurves[j]; if (cd.m_MaxId == topMostCurveID || cd.m_MinId == topMostCurveID) { if (doubleCurve.signedRange == cd.m_SignedRange) { if (cd.m_MaxId > 0) { SetCurve(m_CurveEditor.GetCurveWrapperFromID(cd.m_MaxId), doubleCurve.maxCurve); } if (cd.m_MinId > 0) { SetCurve(m_CurveEditor.GetCurveWrapperFromID(cd.m_MinId), doubleCurve.minCurve); } } else { Debug.LogWarning("Cannot assign a curves with different signed range"); } } } } }
private IReadOnlyList <SeriesPoint> createSeriesPoints <TXValue, TYValue>(CurveData <TXValue, TYValue> curveData, Func <TYValue, IEnumerable <float> > yProperty, bool addYValuesAsSeparateSeriesPoint) where TYValue : IYValue where TXValue : IXValue { var yAxis = curveData.YAxis; var xAxis = curveData.XAxis; var seriesPoints = new List <SeriesPoint>(); for (int i = 0; i < curveData.XValues.Count; i++) { var xValue = xAxis.ConvertToDisplayUnit(curveData.XValues[i].X); var yValues = yProperty(curveData.YValues[i]); double[] yConvertedValues = yValues.Select(y => yAxis.ConvertToDisplayUnit(y)).ToArray(); if (!valuesAreValidForAxes(xAxis, xValue, yAxis, yConvertedValues)) { continue; } if (addYValuesAsSeparateSeriesPoint) { seriesPoints.AddRange(yConvertedValues.Select(yValue => new SeriesPoint(xValue, yValue))); } else { seriesPoints.Add(new SeriesPoint(xValue, yConvertedValues)); } } return(seriesPoints); }
protected override void Context() { base.Context(); var timeDimension = DomainHelperForSpecs.TimeDimensionForSpecs(); var concDimension = DomainHelperForSpecs.ConcentrationDimensionForSpecs(); _xAxis = new AxisData(timeDimension, timeDimension.DefaultUnit, Scalings.Linear) { Caption = "X" }; _yAxis = new AxisData(concDimension, concDimension.DefaultUnit, Scalings.Linear) { Caption = "Y" }; _chartData = new ChartData <TimeProfileXValue, TimeProfileYValue>(_xAxis, null, null, null); var pane1 = new PaneData <TimeProfileXValue, TimeProfileYValue>(_yAxis) { Caption = "Male" }; var pane2 = new PaneData <TimeProfileXValue, TimeProfileYValue>(_yAxis) { Caption = "Female" }; _chartData.AddPane(pane1); _chartData.AddPane(pane2); var curve1 = new CurveData <TimeProfileXValue, TimeProfileYValue> { Caption = "Liver" }; curve1.Add(new TimeProfileXValue(1), new TimeProfileYValue { Y = 10 }); curve1.Add(new TimeProfileXValue(2), new TimeProfileYValue { LowerValue = 20, UpperValue = 30 }); pane1.AddCurve(curve1); var curve2 = new CurveData <TimeProfileXValue, TimeProfileYValue> { Caption = "Kidney" }; curve2.Add(new TimeProfileXValue(3), new TimeProfileYValue { Y = 40 }); pane2.AddCurve(curve2); _observedData = DomainHelperForSpecs.ObservedData(); var displayPathMapper = A.Fake <IQuantityPathToQuantityDisplayPathMapper>(); var dimensionRepository = A.Fake <IDimensionRepository>(); var observedDataMapper = new DataRepositoryToObservedCurveDataMapper(displayPathMapper, dimensionRepository); var obserevdDataCurves = observedDataMapper.MapFrom(_observedData, new ObservedDataCollection(), concDimension); obserevdDataCurves.Each(pane1.AddObservedCurve); observedDataMapper.MapFrom(_observedData, new ObservedDataCollection(), concDimension).Each(curve => { curve.Visible = false; pane1.AddObservedCurve(curve); }); }
private DataTable getPivotedTable(DataTable table, CurveData <TXValue, TYValue> firstCurve) { const string tableNameSuffix = " Pivoted"; if (firstCurve == null) { return(new DataTable(tableNameSuffix)); } var pivoter = new Pivoter(); var dataFields = GetDataFields(firstCurve); var aggregate = new Aggregate <float, float> { Aggregation = floats => floats.FirstOrDefault(), Name = dataFields.Count == 1 ? dataFields[0] : string.Empty }; var pivotInfo = new PivotInfo(rowFields: GetRowFields(firstCurve), dataFields: dataFields, columnFields: new[] { PANE_CAPTION, CURVE_CAPTION }, aggregates: new[] { aggregate }); var pivotTable = pivoter.PivotData(table.DefaultView, pivotInfo); pivotTable.TableName += tableNameSuffix; //purge empty columns foreach (var column in getEmptyColumns(pivotTable)) { pivotTable.Columns.Remove(column); } PerformSpecificTransformationOnPivotedTable(pivotTable); return(pivotTable); }
protected void GetScopeCurve(string pathprefix) { try { device.Write("Curv?"); device.ReadByteArray(1); int count = Convert.ToInt32(System.Text.Encoding.ASCII.GetString(device.ReadByteArray(1))); int npt = Convert.ToInt32(System.Text.Encoding.ASCII.GetString(device.ReadByteArray(count))); Byte[] waveform = device.ReadByteArray(npt); var data = device.ReadString(); CurveData curvedata = new CurveData() { MetaData = meta, Points = new List <CurvePoint>(), Orginal = new List <int>() }; // int length = Convert.ToInt32(data[1].ToString()); for (int j = 0; j < npt; j++) { int pointData = (int)waveform[j] - 128; curvedata.Orginal.Add(pointData); CurvePoint point = new CurvePoint() { X = meta.Xzero + meta.Xincr * (j - meta.Ptoff), Y = meta.Yzero + meta.YMult * (pointData - meta.Yoff) }; curvedata.Points.Add(point); //sum up if (curveNumber == 0) { sumDData.Add(point); } else { sumDData[j].Y += point.Y; } } //raw.Trace(JsonConvert.SerializeObject(curvedata.Orginal)); //translated.Debug(JsonConvert.SerializeObject(curvedata.Points)); Clients.All.getData(curvedata); if (!string.IsNullOrEmpty(pathprefix)) { Task.Run(() => File.WriteAllText(System.IO.Path.Combine(pathprefix, $"raw_{curveNumber}"), JsonConvert.SerializeObject(curvedata.Orginal), System.Text.Encoding.ASCII)); } //curveNumber++; Interlocked.Increment(ref curveNumber); } catch (Exception) { } finally { device.Clear(); //may need sleep to allow camera //Thread.Sleep(1000); } }
void LoadAnimationData() { //if (animFig_ == null) { // Debug.Log("please assign animation fig"); // return; //} //ClipData clipData = new ClipData(); //TranversCollectJoints_r(animFig_, -1, clipData.Joints); //foreach(var j in clipData.Joints) { // Debug.Log(j.Name); //} var bindings = AnimationUtility.GetCurveBindings(animation_); for (int i = 0; i < bindings.Length; i++) { var binding = bindings[i]; //Debug.Log(i + " " + binding.path + "$" + binding.propertyName); if (binding.propertyName == "m_LocalScale.x" || binding.propertyName == "m_LocalScale.y" || binding.propertyName == "m_LocalScale.z") { continue; } AnimationCurve curveFrom = AnimationUtility.GetEditorCurve(animation_, binding); CurveData curveTo = new CurveData { Path = binding.path, Channel = GetChannelType(binding.propertyName) }; //Debug.Log("number of keys " + curveFrom.length); for (int j = 0; j < curveFrom.length; j++) { Keyframe frame = curveFrom.keys[j]; CurveData.Key key = new CurveData.Key { Time = frame.time, Value = frame.value, Tangent = frame.inTangent }; //string key = string.Format("key: time {0} value {1} inTanget {2} outTanget{3}", frame.time, frame.value, frame.inTangent, frame.outTangent); //Debug.Log(key); curveTo.Datas.Add(key); } //clipData.Curves.Add(curveTo); } //Debug.Log("got curves " + clipData.Curves.Count); //using (var file = File.Create("I:/clipData.bin")) { // Serializer.Serialize(file, clipData); //} }
private void Add(CurveData cd) { this.m_CurveEditor.SelectNone(); this.m_AddedCurves.Add(cd); this.ContentChanged(); SessionState.SetVector3(cd.m_UniqueName, new Vector3(cd.m_Color.r, cd.m_Color.g, cd.m_Color.b)); this.UpdateRangeBasedOnShownCurves(); }
void DoReduction(CurveData cv) { int before = cv.length; AnimationCurveKeyReducer.DoReduction(cv.curve, cv.epsilon); int after = cv.length; m_reporter.Write(" key reduction: " + cv.field + " " + before + " -> " + after + "\n"); }
void ConvertXform(UsdXform xf, string path) { if (xf == null) { return; } var ttrans = typeof(Transform); var cvs = new CurveData[] { new CurveData(ttrans, path, "m_LocalPosition.x", m_epsilon_Position), new CurveData(ttrans, path, "m_LocalPosition.y", m_epsilon_Position), new CurveData(ttrans, path, "m_LocalPosition.z", m_epsilon_Position), new CurveData(ttrans, path, "m_LocalRotation.x", m_epsilon_Rotation), new CurveData(ttrans, path, "m_LocalRotation.y", m_epsilon_Rotation), new CurveData(ttrans, path, "m_LocalRotation.z", m_epsilon_Rotation), new CurveData(ttrans, path, "m_LocalRotation.w", m_epsilon_Rotation), new CurveData(ttrans, path, "m_LocalScale.x", m_epsilon_Scale), new CurveData(ttrans, path, "m_LocalScale.y", m_epsilon_Scale), new CurveData(ttrans, path, "m_LocalScale.z", m_epsilon_Scale), }; usdi.usdiXformEachSample(xf.nativeXformPtr, (ref usdi.XformData data, double t_) => { float t = (float)t_ * m_rcpTimeScale; if (data.flags.updatedPosition) { cvs[0].curve.AddKey(t, data.position.x); cvs[1].curve.AddKey(t, data.position.y); cvs[2].curve.AddKey(t, data.position.z); } if (data.flags.updatedRotation) { cvs[3].curve.AddKey(t, data.rotation.x); cvs[4].curve.AddKey(t, data.rotation.y); cvs[5].curve.AddKey(t, data.rotation.z); cvs[6].curve.AddKey(t, data.rotation.w); } if (data.flags.updatedScale) { cvs[7].curve.AddKey(t, data.scale.x); cvs[8].curve.AddKey(t, data.scale.y); cvs[9].curve.AddKey(t, data.scale.z); } }); if (m_keyframeReduction) { foreach (var c in cvs) { DoReduction(c); } } foreach (var c in cvs) { c.Set(m_animClip); } }
protected override void Context() { base.Context(); var timeDimension = DomainHelperForSpecs.TimeDimensionForSpecs(); var concDimension = DomainHelperForSpecs.ConcentrationDimensionForSpecs(); _xAxis = new AxisData(timeDimension, timeDimension.DefaultUnit, Scalings.Linear) { Caption = "X" }; _yAxis = new AxisData(concDimension, concDimension.DefaultUnit, Scalings.Linear) { Caption = "Y" }; _chartData = new ChartData <RangeXValue, RangeYValue>(_xAxis, null); var pane1 = new PaneData <RangeXValue, RangeYValue>(_yAxis) { Caption = "Male" }; var pane2 = new PaneData <RangeXValue, RangeYValue>(_yAxis) { Caption = "Female" }; _chartData.AddPane(pane1); _chartData.AddPane(pane2); var curve1 = new CurveData <RangeXValue, RangeYValue> { Caption = "Liver" }; curve1.Add(new RangeXValue(1) { Minimum = 0, Maximum = 1.5f, NumberOfItems = 5 }, new RangeYValue { LowerPercentile = 10, Median = 20, UpperPercentile = 30 }); curve1.Add(new RangeXValue(2) { Minimum = 1.8f, Maximum = 2.5f, NumberOfItems = 10 }, new RangeYValue { LowerPercentile = 20, Median = 30, UpperPercentile = 40 }); pane1.AddCurve(curve1); var curve2 = new CurveData <RangeXValue, RangeYValue> { Caption = "Kidney" }; curve2.Add(new RangeXValue(3) { Minimum = 2f, Maximum = 4f, NumberOfItems = 15 }, new RangeYValue { LowerPercentile = 30, Median = 40, UpperPercentile = 50 }); pane2.AddCurve(curve2); }
protected override void AddSpecificChartColumns(DataTable dataTable, CurveData <BoxWhiskerXValue, BoxWhiskerYValue> curveData, bool exportForPivot) { dataTable.AddColumn(_xValue); dataTable.AddColumn <float>(_lowerWhisker); dataTable.AddColumn <float>(_lowerBox); dataTable.AddColumn <float>(_median); dataTable.AddColumn <float>(_upperBox); dataTable.AddColumn <float>(_upperWhisker); dataTable.AddColumn(_variable); }
protected override IReadOnlyList <Series> CreateCurveSeriesList(CurveData <RangeXValue, RangeYValue> curveData) { var rangeAreaSeries = CreateRangeAreaSeries(curveData) .WithPoints(CreateSeriesPoints(curveData, y => y.LowerPercentile, y => y.UpperPercentile)); var medianAreaSeries = CreateLineSeries(curveData) .WithPoints(CreateSeriesPoints(curveData, y => y.Median)); return(new[] { rangeAreaSeries, medianAreaSeries }); }
public void AddCurveDataIfNeeded(string curveName, CurveData curveData) { Vector3 vector = SessionState.GetVector3(curveName, Vector3.zero); if (vector != Vector3.zero) { Color color = new Color(vector.x, vector.y, vector.z); curveData.m_Color = color; this.AddCurve(curveData); for (int i = 0; i < this.m_AvailableColors.Count; i++) { if (SameColor(this.m_AvailableColors[i], color)) { this.m_AvailableColors.RemoveAt(i); break; } } } }
public void AddCurve(CurveData curveData) { this.Add(curveData); }
private void DrawCurve(string snapshotName, CurveData curveData, ref int colorIndex) { if (curveData.Curve == null) { PointPairList points = new PointPairList(); for (int i = 0; i < curveData.Data.Count; i++) { points.Add((double) i, (double) curveData.Data[i]); } LineItem item = this.m_ZedGraph.GraphPane.AddCurve(snapshotName + "_" + curveData.Label, points, ViewConstant.COLOR_ARRAY[colorIndex % ViewConstant.COLOR_ARRAY.Length], SymbolType.None); curveData.Curve = item; colorIndex++; } else { this.m_ZedGraph.GraphPane.CurveList.Add(curveData.Curve); } }
public void Save() { BinaryFormatter bf = new BinaryFormatter(); FileStream file = File.Create(Application.dataPath + "/ProceduralTracks/CurvesSavedData/" + gameObject.name + transform.parent.GetComponent<Track>().id + ".curve"); CurveData data = new CurveData(); List<NodeData> _nodesData = new List<NodeData>(); if (nodes != null) { foreach (Node n in nodes) { _nodesData.Add(n.Serialize()); } } data.nodesData = _nodesData.ToArray(); List<BezierData> _splinesData = new List<BezierData>(); foreach (BezierSpline b in splines) { _splinesData.Add(b.GetData()); } data.splinesData = _splinesData.ToArray(); data.closed = this.closed; data.invisible = this.invisible; bf.Serialize(file, data); file.Close(); }