public AxisScaleController(XYPlotLayer layer, int axisnumber) { m_Layer = layer; m_axisNumber = axisnumber; m_Axis = m_Layer.LinkedScales.Scale(axisnumber); _tempAxis = (Scale)m_Axis.Clone(); SetElements(); }
public LinkedScale(Scale scaleToWrap, int scaleNumberLinkedTo) { _linkParameters = new LinkedScaleParameters() { ParentObject = this }; WrappedScale = scaleToWrap; _linkedScaleIndex = scaleNumberLinkedTo; }
public LinkedScale(Scale scaleToWrap) { _linkParameters = new LinkedScaleParameters() { ParentObject = this }; WrappedScale = scaleToWrap; }
public TransformedScale(Scale scale, double offset) { _originalScale = scale; _offset = offset; }
/// <summary> /// Checks if the scale in the argument is dependend on this Scale. This would mean a circular dependency, which should be avoided. /// </summary> /// <param name="scaleThatWouldBecomeALinkedScale">Scale that is a linked scale or that would become a linked scale.</param> /// <param name="scaleToTest">The scale to check.</param> /// <returns>True if the provided scale or one of its linked scales is dependend on this scale.</returns> public static bool WouldScaleBeDependentOnMe(Scale scaleThatWouldBecomeALinkedScale, Scale scaleToTest) { if (object.ReferenceEquals(scaleThatWouldBecomeALinkedScale, scaleToTest)) { return(true); // Scale are identical, thus they are really dependent on each other } var linkedScale = scaleToTest as LinkedScale; while (null != linkedScale) { if (object.ReferenceEquals(scaleThatWouldBecomeALinkedScale, linkedScale)) { return(true); // this means a direct circular dependency (we are at the original scale), so return true } if (object.ReferenceEquals(scaleThatWouldBecomeALinkedScale, linkedScale.ScaleLinkedTo)) { return(true); // That would mean a circular dependency also, thus also return true; } linkedScale = linkedScale.ScaleLinkedTo as LinkedScale; } return(false); // no dependency detected }
public LayerSegment(IPlotArea underlyingArea, Scale scale, Logical3D org, Logical3D end, int scaleNumber) { _underlyingArea = underlyingArea; _org = org; _end = end; _scaleNumber = scaleNumber; for (int i = 0; i < _underlyingArea.Scales.Count; ++i) { if (i == _scaleNumber) _scaleCollection[i] = scale; else _scaleCollection[i] = (Scale)underlyingArea.Scales[i].Clone(); } }
public void SetScale(int i, Scale ax) { _linkedScales[i].Scale = ax; }
/// <summary> /// Checks if the scale in the argument is dependend on this Scale. This would mean a circular dependency, which should be avoided. /// </summary> /// <param name="scaleThatWouldBecomeALinkedScale">Scale that is a linked scale or that would become a linked scale.</param> /// <param name="scaleToTest">The scale to check.</param> /// <returns>True if the provided scale or one of its linked scales is dependend on this scale.</returns> public static bool WouldScaleBeDependentOnMe(Scale scaleThatWouldBecomeALinkedScale, Scale scaleToTest) { if (object.ReferenceEquals(scaleThatWouldBecomeALinkedScale, scaleToTest)) return true; // Scale are identical, thus they are really dependent on each other var linkedScale = scaleToTest as LinkedScale; while (null != linkedScale) { if (object.ReferenceEquals(scaleThatWouldBecomeALinkedScale, linkedScale)) return true; // this means a direct circular dependency (we are at the original scale), so return true if (object.ReferenceEquals(scaleThatWouldBecomeALinkedScale, linkedScale.ScaleLinkedTo)) return true; // That would mean a circular dependency also, thus also return true; linkedScale = linkedScale.ScaleLinkedTo as LinkedScale; } return false; // no dependency detected }
/// <summary> /// Paints the axis style labels. /// </summary> /// <param name="g">Graphics environment.</param> /// <param name="coordSyst">The coordinate system. Used to get the path along the axis.</param> /// <param name="scale">Scale.</param> /// <param name="tickSpacing">If not <c>null</c>, this parameter provides a custom tick spacing that is used instead of the default tick spacing of the scale.</param> /// <param name="styleInfo">Information about begin of axis, end of axis.</param> /// <param name="outerDistance">Distance between axis and labels.</param> /// <param name="useMinorTicks">If true, minor ticks are shown.</param> public virtual void Paint(IGraphicsContext3D g, G3DCoordinateSystem coordSyst, Scale scale, TickSpacing tickSpacing, CSAxisInformation styleInfo, double outerDistance, bool useMinorTicks) { _cachedAxisStyleInfo = styleInfo; CSLineID styleID = styleInfo.Identifier; Scale raxis = scale; TickSpacing ticking = tickSpacing; var math = Matrix4x3.Identity; Logical3D r0 = styleID.GetLogicalPoint(styleInfo.LogicalValueAxisOrg); Logical3D r1 = styleID.GetLogicalPoint(styleInfo.LogicalValueAxisEnd); VectorD3D outVector; Logical3D outer; double[] relpositions; AltaxoVariant[] ticks; if (useMinorTicks) { relpositions = ticking.GetMinorTicksNormal(raxis); ticks = ticking.GetMinorTicksAsVariant(); } else { relpositions = ticking.GetMajorTicksNormal(raxis); ticks = ticking.GetMajorTicksAsVariant(); } if (!_suppressedLabels.IsEmpty) { List<AltaxoVariant> filteredTicks = new List<AltaxoVariant>(); List<double> filteredRelPositions = new List<double>(); for (int i = 0; i < ticks.Length; i++) { if (_suppressedLabels.ByValues.Contains(ticks[i])) continue; if (_suppressedLabels.ByNumbers.Contains(i)) continue; if (_suppressedLabels.ByNumbers.Contains(i - ticks.Length)) continue; filteredTicks.Add(ticks[i]); filteredRelPositions.Add(relpositions[i]); } ticks = filteredTicks.ToArray(); relpositions = filteredRelPositions.ToArray(); } IMeasuredLabelItem[] labels = _labelFormatting.GetMeasuredItems(g, _font, ticks); double emSize = _font.Size; CSAxisSide labelSide = null != _labelSide ? _labelSide.Value : styleInfo.PreferredLabelSide; var labelOutlines = new RectangularObjectOutline[ticks.Length]; for (int i = 0; i < ticks.Length; i++) { double r = relpositions[i]; if (!Altaxo.Calc.RMath.IsInIntervalCC(r, -1000, 1000)) continue; outer = coordSyst.GetLogicalDirection(styleID.ParallelAxisNumber, labelSide); PointD3D tickorg = coordSyst.GetPositionAndNormalizedDirection(r0, r1, r, outer, out outVector); PointD3D tickend = tickorg + outVector * outerDistance; var msize = labels[i].Size; var morg = tickend; if (_automaticRotationShift) { // if this option is choosen, we have to find a shift value that shifts the center of the text outwards so that the bounding box of the text will not cross the plane that is // defined by the tickend point and the normal vector outVector // Assume that the text is now centered x, y, and z around the point tickend (but here we use origin instead tickend) math = Matrix4x3.NewRotation(_rotationX, _rotationY, _rotationZ); // we have to find all points with negative distance to the plane spanned by tickend and the vector outVector (but again instead of tickend we use origin) var msizePad = msize + new VectorD3D( (_font.Size * 1) / 3, // whereas above and below text no padding is neccessary, it is optically nicer to have left and right padding of the string by 1/6 of font size. 0, (_font.Size * 1) / 3 // same padding applies to z ); var crect = new RectangleD3D((PointD3D)(-0.5 * msizePad), msizePad); // our text centered around origin double shift = 0; foreach (PointD3D p in crect.Vertices) { PointD3D ps = math.Transform(p); double distance = Math3D.GetDistancePointToPlane(ps, PointD3D.Empty, outVector); if (-distance > shift) shift = -distance; // only negative distances will count here } morg += outVector * shift; } else { morg = morg.WithXPlus(outVector.X * _font.Size / 3); } var mrect = new RectangleD3D(morg, msize); if (_automaticRotationShift) mrect = AdjustRectangle(mrect, Alignment.Center, Alignment.Center, Alignment.Center); else mrect = AdjustRectangle(mrect, _alignmentX, _alignmentY, _alignmentZ); math = Matrix4x3.Identity; math.TranslatePrepend(morg.X, morg.Y, morg.Z); if (this._rotationZ != 0) math.RotationZDegreePrepend(this._rotationZ); if (this._rotationY != 0) math.RotationYDegreePrepend(this._rotationY); if (this._rotationX != 0) math.RotationXDegreePrepend(this._rotationX); math.TranslatePrepend((mrect.X - morg.X + emSize * _offsetX), (mrect.Y - morg.Y + emSize * _offsetY), (mrect.Z - morg.Z + emSize * _offsetZ)); var gs = g.SaveGraphicsState(); g.PrependTransform(math); if (this._backgroundStyle != null) { var itemRectangle = new RectangleD3D(PointD3D.Empty, msize); _backgroundStyle.Measure(itemRectangle); _backgroundStyle.Draw(g, itemRectangle); } labels[i].Draw(g, _brush, PointD3D.Empty); labelOutlines[i] = new RectangularObjectOutline(new RectangleD3D(PointD3D.Empty, msize), math); g.RestoreGraphicsState(gs); // Restore the graphics state } _cachedLabelOutlines = labelOutlines; }
public void EhView_AxisTypeChanged(string text) { m_AxisType = text; try { System.Type axistype = (System.Type)Scale.AvailableAxes[m_AxisType]; if(null!=axistype) { if(axistype!=_tempAxis.GetType()) { // replace the current axis by a new axis of the type axistype Scale _oldAxis = _tempAxis; _tempAxis = (Scale)System.Activator.CreateInstance(axistype); // Try to set the same org and end as the axis before // this will fail for instance if we switch from linear to logarithmic with negative bounds try { _tempAxis.ProcessDataBounds(_oldAxis.OrgAsVariant,true,_oldAxis.EndAsVariant,true); } catch(Exception) { } SetScaleController(true); // now we have also to replace the controller and the control for the axis boundaries SetBoundaryController(true); } } } catch(Exception ) { } }
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 bool CopyFrom(object obj) { if (object.ReferenceEquals(this, obj)) return true; var from = obj as ScaleSegment; if (null == from) return false; using (var suspendToken = SuspendGetToken()) { this._relOrg = from._relOrg; this._relEnd = from._relEnd; this._underlyingScale = from._underlyingScale; this._segmentScaling = from._segmentScaling; EhSelfChanged(EventArgs.Empty); suspendToken.Resume(); } return true; }
public ScaleSegment(Scale underlyingScale, double relOrg, double relEnd, ScaleSegmentType scaling) { if (null == underlyingScale) throw new ArgumentNullException("underlyingScale"); _underlyingScale = underlyingScale; _relOrg = relOrg; _relEnd = relEnd; _segmentScaling = scaling; }
protected override System.Collections.Generic.IEnumerable<Main.DocumentNodeAndName> GetDocumentNodeChildrenWithName() { if (null != _scaleWrapped) yield return new Main.DocumentNodeAndName(_scaleWrapped, () => _scaleWrapped = null, "ScaleWrapped"); if (null != _linkParameters) yield return new Main.DocumentNodeAndName(_linkParameters, () => _linkParameters = null, "LinkParameters"); if (null != _scaleLinkedToProxy) yield return new Main.DocumentNodeAndName(_scaleLinkedToProxy, () => _scaleLinkedToProxy = null, "ScaleLinkedTo"); }
public AxisScaleController(XYPlotLayer layer, Scale ax) { m_Layer = layer; m_axisNumber = layer.LinkedScales.IndexOf(ax); if (m_axisNumber < 0) throw new ArgumentException("Provided axis is not member of the layer"); m_Axis = ax; _tempAxis = (Scale)m_Axis.Clone(); SetElements(); }
/// <summary> /// Checks if the scale in the argument is dependend on this Scale. This would mean a circular dependency, which should be avoided. /// </summary> /// <param name="scaleToTest">The scale to check.</param> /// <returns>True if the provided scale or one of its linked scales is dependend on this scale.</returns> public bool IsScaleDependentOnMe(Scale scaleToTest) { return WouldScaleBeDependentOnMe(this, scaleToTest); }
/// <summary> /// Measures if the linked axis has changed. /// </summary> /// <param name="linkedAxis">The axis that is the master axis (our axis is linked to this axis).</param> public void EhLinkedLayerAxesChanged(Scale linkedAxis) { if (_isLinked) { // we must disable our own interrogator because otherwise we can not change the axis _scale.IsLinked = false; _scale.ProcessDataBounds( LinkOrgA + LinkOrgB * linkedAxis.OrgAsVariant, true, LinkEndA + LinkEndB * linkedAxis.EndAsVariant, true); _scale.IsLinked = true; // restore the linked state of the axis this.OnLinkPropertiesChanged(); // indicate that the axes boundaries have changed } }
/// <summary> /// Paints the axis style labels. /// </summary> /// <param name="g">Graphics environment.</param> /// <param name="coordSyst">The coordinate system. Used to get the path along the axis.</param> /// <param name="scale">Scale.</param> /// <param name="tickSpacing">If not <c>null</c>, this parameter provides a custom tick spacing that is used instead of the default tick spacing of the scale.</param> /// <param name="styleInfo">Information about begin of axis, end of axis.</param> /// <param name="outerDistance">Distance between axis and labels.</param> /// <param name="useMinorTicks">If true, minor ticks are shown.</param> public virtual void Paint(Graphics g, G2DCoordinateSystem coordSyst, Scale scale, TickSpacing tickSpacing, CSAxisInformation styleInfo, double outerDistance, bool useMinorTicks) { _cachedAxisStyleInfo = styleInfo; CSLineID styleID = styleInfo.Identifier; Scale raxis = scale; TickSpacing ticking = tickSpacing; _enclosingPath.Reset(); _enclosingPath.FillMode = FillMode.Winding; // with Winding also overlapping rectangles are selected GraphicsPath helperPath = new GraphicsPath(); Matrix math = new Matrix(); Logical3D r0 = styleID.GetLogicalPoint(styleInfo.LogicalValueAxisOrg); Logical3D r1 = styleID.GetLogicalPoint(styleInfo.LogicalValueAxisEnd); PointD2D outVector; Logical3D outer; var dist_x = outerDistance; // Distance from axis tick point to label var dist_y = outerDistance; // y distance from axis tick point to label // dist_x += this._font.SizeInPoints/3; // add some space to the horizontal direction in order to separate the chars a little from the ticks // next statement is necessary to have a consistent string length both // on 0 degree rotated text and rotated text // without this statement, the text is fitted to the pixel grid, which // leads to "steps" during scaling g.TextRenderingHint = System.Drawing.Text.TextRenderingHint.AntiAlias; double[] relpositions; AltaxoVariant[] ticks; if (useMinorTicks) { relpositions = ticking.GetMinorTicksNormal(raxis); ticks = ticking.GetMinorTicksAsVariant(); } else { relpositions = ticking.GetMajorTicksNormal(raxis); ticks = ticking.GetMajorTicksAsVariant(); } if (!_suppressedLabels.IsEmpty) { List<AltaxoVariant> filteredTicks = new List<AltaxoVariant>(); List<double> filteredRelPositions = new List<double>(); for (int i = 0; i < ticks.Length; i++) { if (_suppressedLabels.ByValues.Contains(ticks[i])) continue; if (_suppressedLabels.ByNumbers.Contains(i)) continue; if (_suppressedLabels.ByNumbers.Contains(i - ticks.Length)) continue; filteredTicks.Add(ticks[i]); filteredRelPositions.Add(relpositions[i]); } ticks = filteredTicks.ToArray(); relpositions = filteredRelPositions.ToArray(); } IMeasuredLabelItem[] labels = _labelFormatting.GetMeasuredItems(g, _font, _stringFormat, ticks); double emSize = _font.Size; CSAxisSide labelSide = null != _labelSide ? _labelSide.Value : styleInfo.PreferredLabelSide; for (int i = 0; i < ticks.Length; i++) { double r = relpositions[i]; if (!Altaxo.Calc.RMath.IsInIntervalCC(r, -1000, 1000)) continue; outer = coordSyst.GetLogicalDirection(styleID.ParallelAxisNumber, labelSide); PointD2D tickorg = coordSyst.GetNormalizedDirection(r0, r1, r, outer, out outVector); PointD2D tickend = tickorg + outVector * outerDistance; PointD2D msize = labels[i].Size; PointD2D morg = tickend; if (_automaticRotationShift) { double alpha = _rotation * Math.PI / 180 - Math.Atan2(outVector.Y, outVector.X); double shift = msize.Y * 0.5 * Math.Abs(Math.Sin(alpha)) + (msize.X + _font.Size / 2) * 0.5 * Math.Abs(Math.Cos(alpha)); morg = morg + outVector * shift; } else { morg = morg.WithXPlus(outVector.X * _font.Size / 3); } RectangleD2D mrect = new RectangleD2D(morg, msize); if (_automaticRotationShift) AdjustRectangle(ref mrect, StringAlignment.Center, StringAlignment.Center); else AdjustRectangle(ref mrect, _horizontalAlignment, _verticalAlignment); math.Reset(); math.Translate((float)morg.X, (float)morg.Y); if (this._rotation != 0) { math.Rotate((float)-this._rotation); } math.Translate((float)(mrect.X - morg.X + emSize * _xOffset), (float)(mrect.Y - morg.Y + emSize * _yOffset)); System.Drawing.Drawing2D.GraphicsState gs = g.Save(); g.MultiplyTransform(math); if (this._backgroundStyle != null) _backgroundStyle.Draw(g, new RectangleD2D(PointD2D.Empty, msize)); _brush.SetEnvironment(new RectangleD2D(PointD2D.Empty, msize), BrushX.GetEffectiveMaximumResolution(g, 1)); labels[i].Draw(g, _brush, new PointF(0, 0)); g.Restore(gs); // Restore the graphics state helperPath.Reset(); helperPath.AddRectangle(new RectangleF(PointF.Empty, (SizeF)msize)); helperPath.Transform(math); _enclosingPath.AddPath(helperPath, true); } }
/// <summary> /// Checks if the scale in the argument is dependend on this Scale. This would mean a circular dependency, which should be avoided. /// </summary> /// <param name="scaleToTest">The scale to check.</param> /// <returns>True if the provided scale or one of its linked scales is dependend on this scale.</returns> public bool IsScaleDependentOnMe(Scale scaleToTest) { return(WouldScaleBeDependentOnMe(this, scaleToTest)); }
public int IndexOf(Scale ax) { for (int i = 0; i < _linkedScales.Length; i++) { if (_linkedScales[i].Scale == ax) return i; } return -1; }