public void T001_MajorTicksSpacedOne() { var scale = new LinearScale(); var s = (LinearTickSpacing)scale.TickSpacing; s.OrgGrace = 0; s.EndGrace = 0; s.ZeroLever = 0; for (int tmt = 4; tmt <= 16; ++tmt) { s.TargetNumberOfMajorTicks = tmt; s.TargetNumberOfMinorTicks = 1; s.FinalProcessScaleBoundaries(0, tmt - 1, scale); var majorTicks = s.GetMajorTicks(); Assert.IsNotNull(majorTicks); Assert.AreEqual(tmt, majorTicks.Length); for (int i = 0; i <= tmt - 1; ++i) Assert.AreEqual(majorTicks[i], i); } }
public object Deserialize(object o, Altaxo.Serialization.Xml.IXmlDeserializationInfo info, object parent) { LinearScale s = null != o ? (LinearScale)o : new LinearScale(); s._baseOrg = (double)info.GetDouble("BaseOrg"); s._baseEnd = (double)info.GetDouble("BaseEnd"); s._majorSpan = (double)info.GetDouble("MajorSpan"); s._minorTicks = (int)info.GetInt32("MinorTicks"); s._axisOrgByMajor = (double)info.GetDouble("OrgByMajor"); s._axisEndByMajor = (double)info.GetDouble("EndByMajor"); bool AxisOrgFixed = (bool)info.GetBoolean("OrgFixed"); bool AxisEndFixed = (bool)info.GetBoolean("EndFixed"); s._dataBounds = (FiniteNumericalBoundaries)info.GetValue("Bounds", s); s.SetCachedValues(); // restore the event chain s._dataBounds.BoundaryChanged += new BoundaryChangedHandler(s.OnBoundariesChanged); s._rescaling = new NumericAxisRescaleConditions(); s._rescaling.SetOrgAndEnd(AxisOrgFixed ? BoundaryRescaling.Fixed : BoundaryRescaling.Auto, s.Org, AxisEndFixed ? BoundaryRescaling.Fixed:BoundaryRescaling.Auto, s.End); return(s); }
public LinkedScale() { Scale = new LinearScale(); _isLinked = false; _linkOrgA = 0; _linkOrgB = 1; _linkEndA = 0; _linkEndB = 1; }
public ScaleCollection(int numberOfScales) { if (numberOfScales <= 0) { throw new ArgumentOutOfRangeException(nameof(numberOfScales) + " must be >= 1"); } _scales = new Scale[numberOfScales]; for (int i = 0; i < numberOfScales; ++i) { this[i] = new LinearScale(); } }
public void Serialize(object obj, Altaxo.Serialization.Xml.IXmlSerializationInfo info) { LinearScale s = (LinearScale)obj; info.AddValue("BaseOrg", s._baseOrg); info.AddValue("BaseEnd", s._baseEnd); info.AddValue("MajorSpan", s._majorSpan); info.AddValue("MinorTicks", s._minorTicks); info.AddValue("OrgByMajor", s._axisOrgByMajor); info.AddValue("EndByMajor", s._axisEndByMajor); // info.AddValue("OrgFixed",s.m_AxisOrgFixed); // info.AddValue("EndFixed",s.m_AxisEndFixed); info.AddValue("Bounds", s._dataBounds); }
public object Deserialize(object o, Altaxo.Serialization.Xml.IXmlDeserializationInfo info, object parent) { LinearScale s = (LinearScale)o ?? new LinearScale(info); s._cachedAxisOrg = info.GetDouble("Org"); s._cachedAxisEnd = info.GetDouble("End"); s._cachedAxisSpan = s._cachedAxisEnd - s._cachedAxisOrg; s._cachedOneByAxisSpan = 1 / s._cachedAxisSpan; s.ChildSetMember(ref s._rescaling, (NumericScaleRescaleConditions)info.GetValue("Rescaling", s)); s.ChildSetMember(ref s._dataBounds, (FiniteNumericalBoundaries)info.GetValue("Bounds", s)); s.ChildSetMember(ref s._tickSpacing, new Ticks.LinearTickSpacing()); s.EhChildChanged(s._dataBounds, EventArgs.Empty); // for this old version, rescaling is not fully serialized, thus we have to simulate a DataBoundChanged event to get _rescaling updated, and finally _tickSpacing updated return(s); }
public object Deserialize(object o, Altaxo.Serialization.Xml.IXmlDeserializationInfo info, object parent) { LinearScale s = (LinearScale)o ?? new LinearScale(info); s._cachedAxisOrg = info.GetDouble("Org"); s._cachedAxisEnd = info.GetDouble("End"); s._cachedAxisSpan = s._cachedAxisEnd - s._cachedAxisOrg; s._cachedOneByAxisSpan = 1 / s._cachedAxisSpan; s.ChildSetMember(ref s._dataBounds, (FiniteNumericalBoundaries)info.GetValue("Bounds", s)); s.ChildSetMember(ref s._rescaling, (NumericScaleRescaleConditions)info.GetValue("Rescaling", s)); s.ChildSetMember(ref s._tickSpacing, (Ticks.TickSpacing)info.GetValue("TickSpacing", s)); s.UpdateTicksAndOrgEndUsingRescalingObject(); return(s); }
/// <summary> /// Copy constructor. /// </summary> /// <param name="from">A other linear axis from which to copy from.</param> public LinearScale(LinearScale from) { this.IsLinked = from.IsLinked; this._cachedAxisEnd = from._cachedAxisEnd; this._axisEndByMajor = from._axisEndByMajor; this._cachedAxisOrg = from._cachedAxisOrg; this._axisOrgByMajor = from._axisOrgByMajor; this._cachedAxisSpan = from._cachedAxisSpan; this._baseEnd = from._baseEnd; this._baseOrg = from._baseOrg; this._dataBounds = null == from._dataBounds ? new FiniteNumericalBoundaries() : (NumericalBoundaries)from._dataBounds.Clone(); _dataBounds.BoundaryChanged += new BoundaryChangedHandler(this.OnBoundariesChanged); this._majorSpan = from._majorSpan; this._minorTicks = from._minorTicks; this._cachedOneByAxisSpan = from._cachedOneByAxisSpan; this._rescaling = null == from.Rescaling ? new NumericAxisRescaleConditions() : (NumericAxisRescaleConditions)from.Rescaling.Clone(); }
private void SetupOldAxis(int idx, Altaxo.Graph.Scales.Deprecated.Scale axis, bool isLinked, double orgA, double orgB, double endA, double endB) { Scale transScale = null; if (axis is Altaxo.Graph.Scales.Deprecated.TextScale) transScale = new TextScale(); else if (axis is Altaxo.Graph.Scales.Deprecated.DateTimeScale) transScale = new DateTimeScale(); else if (axis is Altaxo.Graph.Scales.Deprecated.Log10Scale) transScale = new Log10Scale(); else if (axis is Altaxo.Graph.Scales.Deprecated.AngularScale) transScale = (axis as Altaxo.Graph.Scales.Deprecated.AngularScale).UseDegrees ? (Scale)new AngularDegreeScale() : (Scale)new AngularRadianScale(); else if (axis is Altaxo.Graph.Scales.Deprecated.LinearScale) transScale = new LinearScale(); else throw new ArgumentException("Axis type unknown"); if (transScale.RescalingObject is IUnboundNumericScaleRescaleConditions) (transScale.RescalingObject as IUnboundNumericScaleRescaleConditions).SetUserParameters(BoundaryRescaling.AutoTempFixed, BoundariesRelativeTo.Absolute, axis.OrgAsVariant, BoundaryRescaling.AutoTempFixed, BoundariesRelativeTo.Absolute, axis.EndAsVariant); if (transScale.RescalingObject is Altaxo.Graph.Scales.Rescaling.NumericScaleRescaleConditions && axis.RescalingObject is Altaxo.Graph.Scales.Rescaling.NumericScaleRescaleConditions) { ((Altaxo.Graph.Scales.Rescaling.NumericScaleRescaleConditions)transScale.RescalingObject).CopyFrom((Altaxo.Graph.Scales.Rescaling.NumericScaleRescaleConditions)axis.RescalingObject); } if (isLinked) { #pragma warning disable CS0618 // Type or member is obsolete LinkedScale ls = new LinkedScale(transScale, idx); #pragma warning restore CS0618 // Type or member is obsolete ls.SetLinkParameter(orgA, orgB, endA, endB); transScale = ls; } _scales[idx] = transScale; }
public void T002_TestZeroLever() { var scale = new LinearScale(); var s = (LinearTickSpacing)scale.TickSpacing; s.OrgGrace = 0; s.EndGrace = 0; s.ZeroLever = 0; Altaxo.Data.AltaxoVariant org, end; s.ZeroLever = 0.25; for (int i = 0; i < 50; ++i) { org = i; end = i + 100; // Span now is 100 s.PreProcessScaleBoundaries(ref org, ref end, true, true); Assert.AreEqual(i <= 25 ? 0 : i, org.ToDouble()); Assert.AreEqual(i + 100, end.ToDouble()); } }
/// <summary> /// Copy constructor. /// </summary> /// <param name="from">A other linear axis from which to copy from.</param> public LinearScale(LinearScale from) { CopyFrom(from); }
public DensityLegendArea(PointD2D size, bool isXYInterchanged, bool isXReversed, Scale scale, TickSpacing tickSpacing) { _size = size; _scales = new ScaleCollection() { ParentObject = this }; _scales[0] = scale; scale.TickSpacing = tickSpacing; _scales[1] = new LinearScale() { TickSpacing = new NoTickSpacing() }; _coordinateSystem = new Altaxo.Graph.Gdi.CS.G2DCartesicCoordinateSystem() { ParentObject = this }; _coordinateSystem.IsXYInterchanged = isXYInterchanged; _coordinateSystem.IsXReverse = isXReversed; _coordinateSystem.UpdateAreaSize(_size); }
public override void Paint(System.Drawing.Graphics g, IPaintContext paintContext) { if (null == _cachedArea) return; bool orientationIsVertical = IsOrientationVertical; bool scaleIsReversed = IsScaleReversed; int pixelH = orientationIsVertical ? _bitmapPixelsAcross : _bitmapPixelsAlong; int pixelV = orientationIsVertical ? _bitmapPixelsAlong : _bitmapPixelsAcross; if (null == _bitmap || _bitmap.Width != pixelH || _bitmap.Height != pixelV) { if (null != _bitmap) _bitmap.Dispose(); _bitmap = new Bitmap(pixelH, pixelV, System.Drawing.Imaging.PixelFormat.Format32bppArgb); } Data.AltaxoVariant porg; Data.AltaxoVariant pend; NumericalScale originalZScale; Plot.IColorProvider colorProvider; if (null != PlotItem) { porg = PlotItem.Style.Scale.OrgAsVariant; pend = PlotItem.Style.Scale.EndAsVariant; originalZScale = PlotItem.Style.Scale; colorProvider = PlotItem.Style.ColorProvider; } else { porg = 0; pend = 1; originalZScale = new LinearScale(); colorProvider = new Plot.ColorProvider.ColorProviderBGRY(); } var legendScale = (NumericalScale)ScaleWithTicks; var legendTickSpacing = ScaleWithTicks.TickSpacing; // Fill the bitmap for (int i = 0; i < _bitmapPixelsAlong; i++) { double r = (scaleIsReversed ^ orientationIsVertical) ? 1 - i / (double)(_bitmapPixelsAlong - 1) : i / (double)(_bitmapPixelsAlong - 1); double l = originalZScale.PhysicalToNormal(legendScale.NormalToPhysical(r)); var color = colorProvider.GetColor(l); if (orientationIsVertical) { for (int j = 0; j < _bitmapPixelsAcross; j++) _bitmap.SetPixel(j, i, color); } else { for (int j = 0; j < _bitmapPixelsAcross; j++) _bitmap.SetPixel(i, j, color); } } var graphicsState = g.Save(); TransformGraphics(g); { // Three tricks are neccessary to get the color legend (which is the bitmap) drawn smooth and uniformly: // Everything other than this will result in distorted image, or soft (unsharp) edges var graphicsState2 = g.Save(); // Of course, save the graphics state so we can make our tricks undone afterwards g.InterpolationMode = InterpolationMode.Default; // Trick1: Set the interpolation mode, whatever it was before, back to default g.PixelOffsetMode = PixelOffsetMode.Default; // Trick2: Set the PixelOffsetMode, whatever it was before, back to default g.DrawImage(_bitmap, new RectangleF(0, 0, (float)Size.X, (float)Size.Y), new Rectangle(0, 0, pixelH - 1, pixelV - 1), GraphicsUnit.Pixel); // Trick3: Paint both in X and Y direction one pixel less than the source bitmap acually has, this prevents soft edges g.Restore(graphicsState2); // make our tricks undone here } _axisStyles.Paint(g, paintContext, _cachedArea); g.Restore(graphicsState); }
public virtual void CopyFrom(LinearScale from) { this._cachedAxisEnd = from._cachedAxisEnd; this._axisEndByMajor = from._axisEndByMajor; this._cachedAxisOrg = from._cachedAxisOrg; this._axisOrgByMajor = from._axisOrgByMajor; this._cachedAxisSpan = from._cachedAxisSpan; this._baseEnd = from._baseEnd; this._baseOrg = from._baseOrg; if(null!=_dataBounds) _dataBounds.BoundaryChanged -= new BoundaryChangedHandler(this.OnBoundariesChanged); this._dataBounds = null==from._dataBounds ? new FiniteNumericalBoundaries() : (NumericalBoundaries)from._dataBounds.Clone(); _dataBounds.BoundaryChanged += new BoundaryChangedHandler(this.OnBoundariesChanged); this._majorSpan = from._majorSpan; this._minorTicks = from._minorTicks; this._cachedOneByAxisSpan = from._cachedOneByAxisSpan; this._rescaling = null==from.Rescaling ? new NumericAxisRescaleConditions() : (NumericAxisRescaleConditions)from.Rescaling.Clone(); }