void DrawScene(DrawingContext dc) { dc.DrawEllipse(new SolidColorBrush(Color.FromArgb(255, 200, 200, 200)), null, new Point(50, 18), 12, 12); dc.DrawEllipse(new SolidColorBrush(Color.FromArgb(255, 200, 200, 200)), new Pen(new SolidColorBrush(Color.FromArgb(255, 100, 100, 100)), 3), new Point(50, 51), 12, 12); dc.DrawEllipse(null, new Pen(new SolidColorBrush(Color.FromArgb(255, 100, 100, 100)), 3), new Point(50, 87), 12, 12); dc.DrawRectangle(new SolidColorBrush(Color.FromArgb(255, 200, 200, 200)), null, new Rect(25, 111, 24, 24)); dc.DrawRectangle(new SolidColorBrush(Color.FromArgb(255, 200, 200, 200)), new Pen(new SolidColorBrush(Color.FromArgb(255, 100, 100, 100)), 3), new Rect(25, 147, 24, 24)); dc.DrawRectangle(null, new Pen(new SolidColorBrush(Color.FromArgb(255, 100, 100, 100)), 3), new Rect(25, 184, 24, 24)); dc.DrawRoundedRectangle(new SolidColorBrush(Color.FromArgb(255, 200, 200, 200)), null, new Rect(25, 237, 24, 24), 5, 5); dc.DrawRoundedRectangle(new SolidColorBrush(Color.FromArgb(255, 200, 200, 200)), new Pen(new SolidColorBrush(Color.FromArgb(255, 100, 100, 100)), 3), new Rect(25, 270, 24, 24), 5, 5); dc.DrawRoundedRectangle(null, new Pen(new SolidColorBrush(Color.FromArgb(255, 100, 100, 100)), 3), new Rect(25, 307, 24, 24), 5, 5); dc.DrawLine(new Pen(new SolidColorBrush(Color.FromArgb(255, 100, 100, 100)), 3), new Point(50, 340), new Point (70, 360)); }
public void OnDraw(object sender, DrawingContext context) { double height = 0; double width = 0; List <KeyValuePair <int, FormattedText> > _text = new List <KeyValuePair <int, FormattedText> >(); for (int i = 0; i < displayPrimes.Count; i++) { DisplayPrime p = displayPrimes[i]; StringBuilder text = new StringBuilder(p.Prime.Name); text.Append(p.Prime.Name.Length < 20 ? "\t\t" : "\t"); text.Append(p.DucatValue + " Ducats"); if (p.PlatinumPrice != "?") { text.Append("\t" + p.PlatinumPrice + " Plat"); } if (!string.IsNullOrWhiteSpace(p.Data.Notes)) { text.Append("\t" + p.Data.Notes); } SolidColorBrush color = p.Data.NumberOwned >= 1 ? Brushes.CadetBlue : Brushes.OrangeRed; // Draw a formatted text string into the DrawingContext. FormattedText Ftext = new FormattedText(text.ToString(), CultureInfo.GetCultureInfo("en-us"), FlowDirection.LeftToRight, Typeface, 13, color, MainWindow.pixelsPerDip); height = Ftext.Height; if (width < Ftext.Width) { width = Ftext.Width; } _text.Add(new KeyValuePair <int, FormattedText>(i, Ftext)); } //Draw a rectangle bellow the text for easier reading context?.DrawRectangle(brush, pen, new Rect(drawStartX - 10, drawStartY - 10, width + 20, ((height + 5) * displayPrimes.Count) + displayPrimes.Count * 7)); foreach (KeyValuePair <int, FormattedText> keyValuePair in _text) { context.DrawText(keyValuePair.Value, new Point(drawStartX, (drawStartY + 25 * keyValuePair.Key))); } }
protected override void OnRender(DrawingContext dc) { string testString = "Formatted MML Document is displayed here!\nPlease implement the user oriented layout logic."; FormattedText formattedText = new FormattedText(testString, CultureInfo.CurrentCulture, FlowDirection.LeftToRight, new Typeface("Verdana"), 30, Brushes.Black); formattedText.MaxTextWidth = 280; formattedText.MaxTextHeight = 280; formattedText.SetForegroundBrush(new LinearGradientBrush(Colors.Blue, Colors.Teal, 90.0), 10, 12); formattedText.SetFontStyle(FontStyles.Italic, 36, 5); formattedText.SetForegroundBrush(new LinearGradientBrush(Colors.Pink, Colors.Crimson, 90.0), 36, 5); formattedText.SetFontSize(36, 36, 5); formattedText.SetFontWeight(FontWeights.Bold, 42, 48); dc.DrawRectangle(Brushes.White, null, new Rect(0, 0, 300, 300)); dc.DrawText(formattedText, new Point(10, 10)); }
protected override void OnRender(DrawingContext drawingContext) { base.OnRender(drawingContext); var track = game.Track; dirtBrush.Viewport = new Rect(0, 0, 0.5f / track.Tiles.GetLength(0), 0.5f / track.Tiles.GetLength(1)); drawingContext.DrawRectangle(dirtBrush, null, new Rect(0, 0, Track.CELLSIZE * track.Tiles.GetLength(0), Track.CELLSIZE * track.Tiles.GetLength(1))); for (var x = 0; x < track.Tiles.GetLength(0); x++) { for (var y = 0; y < track.Tiles.GetLength(1); y++) { switch (track.Tiles[x, y]) { case TrackTile.Gras: DrawTile(drawingContext, TrackTile.Gras, x, y, grasTiles); break; case TrackTile.Sand: DrawTile(drawingContext, TrackTile.Sand, x, y, sandTiles); break; case TrackTile.Road: DrawTile(drawingContext, TrackTile.Road, x, y, roadTiles); break; case TrackTile.GoalDown: drawingContext.DrawRectangle(goalVerticalLeft, null, new Rect( (x * Track.CELLSIZE), (y * Track.CELLSIZE) + (Track.CELLSIZE / 2), Track.CELLSIZE / 2, Track.CELLSIZE / 2)); drawingContext.DrawRectangle(goalVerticalRight, null, new Rect( (x * Track.CELLSIZE) + (Track.CELLSIZE / 2), (y * Track.CELLSIZE) + (Track.CELLSIZE / 2), Track.CELLSIZE / 2, Track.CELLSIZE / 2)); drawingContext.DrawRectangle(roadTiles[TileType.Left], null, new Rect( (x * Track.CELLSIZE), (y * Track.CELLSIZE), Track.CELLSIZE / 2, Track.CELLSIZE / 2)); drawingContext.DrawRectangle(roadTiles[TileType.Right], null, new Rect( (x * Track.CELLSIZE) + (Track.CELLSIZE / 2), (y * Track.CELLSIZE), Track.CELLSIZE / 2, Track.CELLSIZE / 2)); drawingContext.DrawRectangle(startPositionDown, null, new Rect( (x * Track.CELLSIZE), (y * Track.CELLSIZE), Track.CELLSIZE / 2, Track.CELLSIZE / 2)); drawingContext.DrawRectangle(startPositionDown, null, new Rect( (x * Track.CELLSIZE) + (Track.CELLSIZE / 2), (y * Track.CELLSIZE), Track.CELLSIZE / 2, Track.CELLSIZE / 2)); break; case TrackTile.GoalLeft: drawingContext.DrawRectangle(goalHorizontalTop, null, new Rect( (x * Track.CELLSIZE), (y * Track.CELLSIZE), Track.CELLSIZE / 2, Track.CELLSIZE / 2)); drawingContext.DrawRectangle(goalHorizontalBottom, null, new Rect( (x * Track.CELLSIZE), (y * Track.CELLSIZE) + (Track.CELLSIZE / 2), Track.CELLSIZE / 2, Track.CELLSIZE / 2)); drawingContext.DrawRectangle(roadTiles[TileType.Upper], null, new Rect( (x * Track.CELLSIZE) + (Track.CELLSIZE / 2), (y * Track.CELLSIZE), Track.CELLSIZE / 2, Track.CELLSIZE / 2)); drawingContext.DrawRectangle(roadTiles[TileType.Lower], null, new Rect( (x * Track.CELLSIZE) + (Track.CELLSIZE / 2), (y * Track.CELLSIZE) + (Track.CELLSIZE / 2), Track.CELLSIZE / 2, Track.CELLSIZE / 2)); drawingContext.DrawRectangle(startPositionLeft, null, new Rect( (x * Track.CELLSIZE) + (Track.CELLSIZE / 2), (y * Track.CELLSIZE), Track.CELLSIZE / 2, Track.CELLSIZE / 2)); drawingContext.DrawRectangle(startPositionLeft, null, new Rect( (x * Track.CELLSIZE) + (Track.CELLSIZE / 2), (y * Track.CELLSIZE) + (Track.CELLSIZE / 2), Track.CELLSIZE / 2, Track.CELLSIZE / 2)); break; case TrackTile.GoalRight: drawingContext.DrawRectangle(goalHorizontalTop, null, new Rect( (x * Track.CELLSIZE) + (Track.CELLSIZE / 2), (y * Track.CELLSIZE), Track.CELLSIZE / 2, Track.CELLSIZE / 2)); drawingContext.DrawRectangle(goalHorizontalBottom, null, new Rect( (x * Track.CELLSIZE) + (Track.CELLSIZE / 2), (y * Track.CELLSIZE) + (Track.CELLSIZE / 2), Track.CELLSIZE / 2, Track.CELLSIZE / 2)); drawingContext.DrawRectangle(roadTiles[TileType.Upper], null, new Rect( (x * Track.CELLSIZE), (y * Track.CELLSIZE), Track.CELLSIZE / 2, Track.CELLSIZE / 2)); drawingContext.DrawRectangle(roadTiles[TileType.Lower], null, new Rect( (x * Track.CELLSIZE), (y * Track.CELLSIZE) + (Track.CELLSIZE / 2), Track.CELLSIZE / 2, Track.CELLSIZE / 2)); drawingContext.DrawRectangle(startPositionRight, null, new Rect( (x * Track.CELLSIZE), (y * Track.CELLSIZE), Track.CELLSIZE / 2, Track.CELLSIZE / 2)); drawingContext.DrawRectangle(startPositionRight, null, new Rect( (x * Track.CELLSIZE), (y * Track.CELLSIZE) + (Track.CELLSIZE / 2), Track.CELLSIZE / 2, Track.CELLSIZE / 2)); break; case TrackTile.GoalUp: drawingContext.DrawRectangle(goalVerticalLeft, null, new Rect( (x * Track.CELLSIZE), (y * Track.CELLSIZE), Track.CELLSIZE / 2, Track.CELLSIZE / 2)); drawingContext.DrawRectangle(goalVerticalRight, null, new Rect( (x * Track.CELLSIZE) + (Track.CELLSIZE / 2), (y * Track.CELLSIZE), Track.CELLSIZE / 2, Track.CELLSIZE / 2)); drawingContext.DrawRectangle(roadTiles[TileType.Left], null, new Rect( (x * Track.CELLSIZE), (y * Track.CELLSIZE) + (Track.CELLSIZE / 2), Track.CELLSIZE / 2, Track.CELLSIZE / 2)); drawingContext.DrawRectangle(roadTiles[TileType.Right], null, new Rect( (x * Track.CELLSIZE) + (Track.CELLSIZE / 2), (y * Track.CELLSIZE) + (Track.CELLSIZE / 2), Track.CELLSIZE / 2, Track.CELLSIZE / 2)); drawingContext.DrawRectangle(startPositionUp, null, new Rect( (x * Track.CELLSIZE), (y * Track.CELLSIZE) + (Track.CELLSIZE / 2), Track.CELLSIZE / 2, Track.CELLSIZE / 2)); drawingContext.DrawRectangle(startPositionUp, null, new Rect( (x * Track.CELLSIZE) + (Track.CELLSIZE / 2), (y * Track.CELLSIZE) + (Track.CELLSIZE / 2), Track.CELLSIZE / 2, Track.CELLSIZE / 2)); break; } } } }
protected override void OnRender(DrawingContext drawingContext) { base.OnRender(drawingContext); drawingContext.DrawRectangle(brush, pen, rect); }
private void Reader_FrameArrived(object sender, BodyFrameArrivedEventArgs e) { bool player = true; bool dataReceived = false; using (BodyFrame bodyFrame = e.FrameReference.AcquireFrame()) { if (bodyFrame != null) { if (this.bodies == null) { this.bodies = new Body[bodyFrame.BodyCount]; } // The first time GetAndRefreshBodyData is called, Kinect will allocate each Body in the array. // As long as those body objects are not disposed and not set to null in the array, // those body objects will be re-used. bodyFrame.GetAndRefreshBodyData(this.bodies); dataReceived = true; } } if (dataReceived) { using (DrawingContext dc = this.drawingGroup.Open()) { // Draw a transparent background to set the render size dc.DrawRectangle(Brushes.Transparent, null, new Rect(0.0, 0.0, this.displayWidth, this.displayHeight)); Pen line = new Pen(Brushes.Red, 1); // Pen line2 = new Pen(Brushes.Red, 4); dc.DrawLine(line, new Point(0, 335), new Point(600, 335)); // dc.DrawLine(line2, new Point(ElbowRightX, ElbowRightY), new Point(ElbowRightX , ElbowRightY+2)); // dc.DrawEllipse(EllipseBrush, null, new Point(350, 232), 5, 5); int penIndex = 0; foreach (Body body in this.bodies) { Pen drawPen = this.bodyColors[penIndex++]; /* if (!Headplay) { Pen drawPen = this.bodyColors[penIndex--]; } * else { Pen drawPen = this.bodyColors[penIndex++]; }*/ if (body.IsTracked && player && Headplay) { player = false; //this.DrawClippedEdges(body, dc); IReadOnlyDictionary <JointType, Joint> joints = body.Joints; // convert the joint points to depth (display) space Dictionary <JointType, Point> jointPoints = new Dictionary <JointType, Point>(); foreach (JointType jointType in joints.Keys) { // sometimes the depth(Z) of an inferred joint may show as negative // clamp down to 0.1f to prevent coordinatemapper from returning (-Infinity, -Infinity) CameraSpacePoint position = joints[jointType].Position; if (position.Z < 0) { position.Z = InferredZPositionClamp; } DepthSpacePoint depthSpacePoint = this.coordinateMapper.MapCameraPointToDepthSpace(position); jointPoints[jointType] = new Point(depthSpacePoint.X, depthSpacePoint.Y); } ProcessGesture(jointPoints); //depthGOGO(jointPoints); this.DrawBody(joints, jointPoints, dc, drawPen); this.DrawHand(body.HandLeftState, jointPoints[JointType.HandLeft], dc); this.DrawHand(body.HandRightState, jointPoints[JointType.HandRight], dc); if (jointPoints[JointType.HandLeft].X > (jointPoints[JointType.ShoulderRight].X) + 10 && righthand == false && start) { righthand = true; lefthand = false; SendKeyDown(Key.PageUp); } if (jointPoints[JointType.HandLeft].X <jointPoints[JointType.ShoulderRight].X && jointPoints[JointType.HandRight].X> jointPoints[JointType.ShoulderLeft].X && start) { righthand = false; lefthand = false; } if (jointPoints[JointType.HandRight].X < (jointPoints[JointType.ShoulderLeft].X) - 10 && lefthand == false && start) { lefthand = true; righthand = false; SendKeyDown(Key.PageDown); } } } // prevent drawing outside of our render area this.drawingGroup.ClipGeometry = new RectangleGeometry(new Rect(0.0, 0.0, this.displayWidth, this.displayHeight)); } } }
protected override void OnRender(DrawingContext dc) { m_BoxEnd.X = this.ScreenGrid.Width; m_BoxEnd.Y = this.ScreenGrid.Height; SolidColorBrush backgroundBrush = new SolidColorBrush(); backgroundBrush = BackColor as SolidColorBrush; Pen outerRectPen = new Pen(m_BorderColor, m_BorderWidth); // Main outer rectangle ... Rect outerRect = new Rect(m_Start, m_BoxEnd); dc.DrawRectangle(backgroundBrush, outerRectPen, outerRect); FormattedText printText; List <TelemetryObject> dispTelemetry = new List <TelemetryObject>(); dispTelemetry = telemetryCollection; foreach (TelemetryObject thisObj in dispTelemetry.ToList <TelemetryObject>()) { // Increment Y value thisObj.yPos++; //------ Advance the active item ------- thisObj.yPos = thisObj.yPos + (m_ScrollSpeed / m_SpeedMultiplier); printBrush = activeBrush; // -- Display the active data ... char[] printArray = thisObj.telemetryData.ToCharArray(); for (int printCount = 0; printCount < thisObj.telemetryData.Length; printCount++) { // Print the Item Vertical printText = new FormattedText( printArray[printCount].ToString().ToUpper(), CultureInfo.GetCultureInfo("en-us"), FlowDirection.LeftToRight, new Typeface("Georgia"), 10, printBrush); // Do not draw outside the box ... // if ( (thisObj.yPos + (printCount * charTall)) < m_BoxEnd.Y) if (((thisObj.yPos - (int)(printCount * charTall)) + BorderWidth < m_BoxEnd.Y) && ((thisObj.yPos - (int)printCount * charTall) > m_Start.Y + m_YStart)) { dc.DrawText(printText, new Point(thisObj.xPos, thisObj.yPos + (printCount * charTall))); } } //-- Trail behind the active item ... //if (thisObj.yPos > (thisObj.telemetryData.Length * charTall)) for (float trailCount = 0; trailCount < (thisObj.tailArray.Length - 1); trailCount++) { if (trailCount <= m_TailFrontLength) { printBrush = trailBrush; } else { printBrush = ghostBrush; } printText = new FormattedText( thisObj.tailArray[(int)trailCount].ToString(), CultureInfo.GetCultureInfo("en-us"), FlowDirection.LeftToRight, new Typeface("Verdana"), 10, printBrush); // Do not draw outside the box ... Bottom && Top if (((thisObj.yPos - (int)(trailCount * charTall)) + BorderWidth < m_BoxEnd.Y) && ((thisObj.yPos - (int)trailCount * charTall) > m_Start.Y + m_YStart)) { dc.DrawText(printText, new Point(thisObj.xPos, ((thisObj.yPos - charTall) - (int)trailCount * charTall))); } } } // -- Clear out any items that have scrolled off screen... List <TelemetryObject> cleanedCollection = new List <TelemetryObject>(); foreach (TelemetryObject thisObj in telemetryCollection) { if ((m_BoxEnd.Y + (thisObj.tailArray.Length * charTall) + (thisObj.telemetryData.Length * charTall)) > thisObj.yPos) { cleanedCollection.Add(thisObj); } else { xPos[(int)thisObj.xPos] = 0; //printStatus("Remove: " + thisObj.telemetryData, dc); } } telemetryCollection = cleanedCollection; foreach (GhostObject ghostTrail in ghostCollection) { // Advance ghost scrollers ghostTrail.yPos = ghostTrail.yPos + (m_GhostScrollSpeed / m_SpeedMultiplier); printBrush = ghostBrush; char[] printArray = ghostTrail.tailArray; for (int printCount = 0; printCount < ghostTrail.tailArray.Length; printCount++) { // Print the Item Vertical printText = new FormattedText( printArray[printCount].ToString(), CultureInfo.GetCultureInfo("en-us"), FlowDirection.LeftToRight, new Typeface(m_GhostFont), 10, printBrush); // Do not draw outside the box ... Bottom && Top if (((ghostTrail.yPos - (int)(printCount * charTall)) + BorderWidth < m_BoxEnd.Y) && ((ghostTrail.yPos - (int)printCount * charTall) > m_Start.Y + m_YStart)) { dc.DrawText(printText, new Point(ghostTrail.xPos, ((ghostTrail.yPos - charTall) - (int)printCount * charTall))); } } } // -- Clear out any items that have scrolled off screen... List <GhostObject> cleanedGhostCollection = new List <GhostObject>(); foreach (GhostObject thisObj in ghostCollection) { if ((m_BoxEnd.Y + (thisObj.tailArray.Length * charTall)) > thisObj.yPos) { cleanedGhostCollection.Add(thisObj); } else { // Replace the one removed... GhostObject newGO = new GhostObject(); int nextGhostTrailx = 0; nextGhostTrailx = getNextGhostTrailx(); int randHeight = rand.Next((int)(m_BoxEnd.Y - (20 * charTall)), 100); newGO.xPos = nextGhostTrailx; newGO.yPos = randHeight; cleanedGhostCollection.Add(newGO); } } ghostCollection = cleanedGhostCollection; }
/// <summary> /// Render callback. /// </summary> protected override void OnRender(DrawingContext drawingContext) { CornerRadius cornerRadius = CornerRadius; Rect shadowBounds = new Rect(new Point(ShadowDepth, ShadowDepth), new Size(RenderSize.Width, RenderSize.Height)); Color color = Color; if (shadowBounds.Width > 0 && shadowBounds.Height > 0 && color.A > 0) { // The shadow is drawn with a dark center the size of the shadow bounds // deflated by shadow depth on each side. double centerWidth = shadowBounds.Right - shadowBounds.Left - 2 * ShadowDepth; double centerHeight = shadowBounds.Bottom - shadowBounds.Top - 2 * ShadowDepth; // Clamp corner radii to be less than 1/2 the side of the inner shadow bounds double maxRadius = Math.Min(centerWidth * 0.5, centerHeight * 0.5); cornerRadius.TopLeft = Math.Min(cornerRadius.TopLeft, maxRadius); cornerRadius.TopRight = Math.Min(cornerRadius.TopRight, maxRadius); cornerRadius.BottomLeft = Math.Min(cornerRadius.BottomLeft, maxRadius); cornerRadius.BottomRight = Math.Min(cornerRadius.BottomRight, maxRadius); // Get the brushes for the 9 regions Brush[] brushes = GetBrushes(color, cornerRadius); // Snap grid to device pixels double centerTop = shadowBounds.Top + ShadowDepth; double centerLeft = shadowBounds.Left + ShadowDepth; double centerRight = shadowBounds.Right - ShadowDepth; double centerBottom = shadowBounds.Bottom - ShadowDepth; // Because of different corner radii there are 6 potential x (or y) lines to snap to double[] guidelineSetX = new double[] { centerLeft, centerLeft + cornerRadius.TopLeft, centerRight - cornerRadius.TopRight, centerLeft + cornerRadius.BottomLeft, centerRight - cornerRadius.BottomRight, centerRight }; double[] guidelineSetY = new double[] { centerTop, centerTop + cornerRadius.TopLeft, centerTop + cornerRadius.TopRight, centerBottom - cornerRadius.BottomLeft, centerBottom - cornerRadius.BottomRight, centerBottom }; drawingContext.PushGuidelineSet(new GuidelineSet(guidelineSetX, guidelineSetY)); // The corner rectangles are drawn drawn ShadowDepth pixels bigger to // account for the blur cornerRadius.TopLeft = cornerRadius.TopLeft + ShadowDepth; cornerRadius.TopRight = cornerRadius.TopRight + ShadowDepth; cornerRadius.BottomLeft = cornerRadius.BottomLeft + ShadowDepth; cornerRadius.BottomRight = cornerRadius.BottomRight + ShadowDepth; // Draw Top row Rect topLeft = new Rect(shadowBounds.Left, shadowBounds.Top, cornerRadius.TopLeft, cornerRadius.TopLeft); drawingContext.DrawRectangle(brushes[TopLeft], null, topLeft); double topWidth = guidelineSetX[2] - guidelineSetX[1]; if (topWidth > 0) { Rect top = new Rect(guidelineSetX[1], shadowBounds.Top, topWidth, ShadowDepth); drawingContext.DrawRectangle(brushes[Top], null, top); } Rect topRight = new Rect(guidelineSetX[2], shadowBounds.Top, cornerRadius.TopRight, cornerRadius.TopRight); drawingContext.DrawRectangle(brushes[TopRight], null, topRight); // Middle row double leftHeight = guidelineSetY[3] - guidelineSetY[1]; if (leftHeight > 0) { Rect left = new Rect(shadowBounds.Left, guidelineSetY[1], ShadowDepth, leftHeight); drawingContext.DrawRectangle(brushes[Left], null, left); } double rightHeight = guidelineSetY[4] - guidelineSetY[2]; if (rightHeight > 0) { Rect right = new Rect(guidelineSetX[5], guidelineSetY[2], ShadowDepth, rightHeight); drawingContext.DrawRectangle(brushes[Right], null, right); } // Bottom row Rect bottomLeft = new Rect(shadowBounds.Left, guidelineSetY[3], cornerRadius.BottomLeft, cornerRadius.BottomLeft); drawingContext.DrawRectangle(brushes[BottomLeft], null, bottomLeft); double bottomWidth = guidelineSetX[4] - guidelineSetX[3]; if (bottomWidth > 0) { Rect bottom = new Rect(guidelineSetX[3], guidelineSetY[5], bottomWidth, ShadowDepth); drawingContext.DrawRectangle(brushes[Bottom], null, bottom); } Rect bottomRight = new Rect(guidelineSetX[4], guidelineSetY[4], cornerRadius.BottomRight, cornerRadius.BottomRight); drawingContext.DrawRectangle(brushes[BottomRight], null, bottomRight); // Fill Center // Because the heights of the top/bottom rects and widths of the left/right rects are fixed // and the corner rects are drawn with the size of the corner, the center // may not be a square. In this case, create a path to fill the area // When the target object's corner radius is 0, only need to draw one rect if (cornerRadius.TopLeft == ShadowDepth && cornerRadius.TopLeft == cornerRadius.TopRight && cornerRadius.TopLeft == cornerRadius.BottomLeft && cornerRadius.TopLeft == cornerRadius.BottomRight) { // All corners of target are 0, render one large rectangle Rect center = new Rect(guidelineSetX[0], guidelineSetY[0], centerWidth, centerHeight); drawingContext.DrawRectangle(brushes[Center], null, center); } else { // If the corner radius is TL=2, TR=1, BL=0, BR=2 the following shows the shape that needs to be created. // _________________ // | |_ // _ _| | // | | // | _ _| // | | // |___________________| // The missing corners of the shape are filled with the radial gradients drawn above // Define shape counter clockwise PathFigure figure = new PathFigure(); if (cornerRadius.TopLeft > ShadowDepth) { figure.StartPoint = new Point(guidelineSetX[1], guidelineSetY[0]); figure.Segments.Add(new LineSegment(new Point(guidelineSetX[1], guidelineSetY[1]), true)); figure.Segments.Add(new LineSegment(new Point(guidelineSetX[0], guidelineSetY[1]), true)); } else { figure.StartPoint = new Point(guidelineSetX[0], guidelineSetY[0]); } if (cornerRadius.BottomLeft > ShadowDepth) { figure.Segments.Add(new LineSegment(new Point(guidelineSetX[0], guidelineSetY[3]), true)); figure.Segments.Add(new LineSegment(new Point(guidelineSetX[3], guidelineSetY[3]), true)); figure.Segments.Add(new LineSegment(new Point(guidelineSetX[3], guidelineSetY[5]), true)); } else { figure.Segments.Add(new LineSegment(new Point(guidelineSetX[0], guidelineSetY[5]), true)); } if (cornerRadius.BottomRight > ShadowDepth) { figure.Segments.Add(new LineSegment(new Point(guidelineSetX[4], guidelineSetY[5]), true)); figure.Segments.Add(new LineSegment(new Point(guidelineSetX[4], guidelineSetY[4]), true)); figure.Segments.Add(new LineSegment(new Point(guidelineSetX[5], guidelineSetY[4]), true)); } else { figure.Segments.Add(new LineSegment(new Point(guidelineSetX[5], guidelineSetY[5]), true)); } if (cornerRadius.TopRight > ShadowDepth) { figure.Segments.Add(new LineSegment(new Point(guidelineSetX[5], guidelineSetY[2]), true)); figure.Segments.Add(new LineSegment(new Point(guidelineSetX[2], guidelineSetY[2]), true)); figure.Segments.Add(new LineSegment(new Point(guidelineSetX[2], guidelineSetY[0]), true)); } else { figure.Segments.Add(new LineSegment(new Point(guidelineSetX[5], guidelineSetY[0]), true)); } figure.IsClosed = true; figure.Freeze(); PathGeometry geometry = new PathGeometry(); geometry.Figures.Add(figure); geometry.Freeze(); drawingContext.DrawGeometry(brushes[Center], null, geometry); } drawingContext.Pop(); } }
private void Render(Point location) { int textStorePosition = 0; bool flipped; if (ParentAtom == null) { flipped = false; } else { flipped = Flipped; } var textStore = new FunctionalGroupTextSource(ParentGroup, flipped); //main textformatter - this does the writing of the visual using (TextFormatter textFormatter = TextFormatter.Create()) { //set up the default paragraph properties var paraprops = new FunctionalGroupTextSource.GenericTextParagraphProperties( FlowDirection.LeftToRight, TextAlignment.Left, true, false, new LabelTextRunProperties(), TextWrapping.NoWrap, GlyphText.SymbolSize, 0d); var anchorRuns = textStore.Runs.Where(f => f.IsAnchor); string anchorString = string.Empty; foreach (var run in anchorRuns) { anchorString += run.Text; } using (TextLine myTextLine = textFormatter.FormatLine(textStore, textStorePosition, 999, paraprops, null)) { IList <TextBounds> textBounds; Rect firstRect = Rect.Empty; if (!Flipped) //isolate them at the beginning { textBounds = myTextLine.GetTextBounds(0, anchorString.Length); } else { //isolate them at the end var start = myTextLine.Length - 1 - anchorString.Length; textBounds = myTextLine.GetTextBounds(start, anchorString.Length); } //add all the bounds together foreach (TextBounds anchorBound in textBounds) { firstRect.Union(anchorBound.Rectangle); } //center will be position close to the origin 0,0 Point center = new Point((firstRect.Left + firstRect.Right) / 2, (firstRect.Top + firstRect.Bottom) / 2); //the displacement vector will be added to each relative coordinate for the glyph run var displacementVector = location - center; //locus is where the text line is drawn var locus = new Point(0, 0) + displacementVector; textBounds = myTextLine.GetTextBounds(0, 999); var obb = textBounds[0].Rectangle; //draw the line of text using (DrawingContext dc = RenderOpen()) { myTextLine.Draw(dc, locus, InvertAxes.None); #if DEBUG #if SHOWBOUNDS obb.Offset(new Vector(locus.X, locus.Y)); dc.DrawRectangle(null, new Pen(new SolidColorBrush(Colors.BlueViolet), 1.0), obb); #endif #endif var glyphRuns = myTextLine.GetIndexedGlyphRuns(); List <Point> outline = new List <Point>(); double advanceWidths = 0d; //build up the convex hull from each glyph //you need to add in the advance widths for each //glyph run as they are traversed, //to the outline foreach (IndexedGlyphRun igr in glyphRuns) { var originalRun = textStore.GetTextRun(igr.TextSourceCharacterIndex); var currentRun = igr.GlyphRun; //need to work out how much the current run has been offset from the baseline var runBounds = myTextLine.GetTextBounds(igr.TextSourceCharacterIndex, igr.TextSourceLength); //get the bounding rect var rect = runBounds[0].TextRunBounds[0].Rectangle; //it's relative to the baseline //adjust it rect.Offset(new Vector(locus.X, locus.Y)); var rectCopy = rect; #if DEBUG #if SHOWBOUNDS dc.DrawRectangle(null, new Pen(new SolidColorBrush(Colors.DarkOrange), 1.0), rect); #endif #endif var runOutline = GlyphUtils.GetOutline(currentRun); //need to see if the run has been super or sub-scripted var variants = originalRun.Properties.TypographyProperties.Variants; if (variants == FontVariants.Subscript || variants == FontVariants.Superscript) { //simply union in the rect -it's easier! outline.AddRange(new[] { rectCopy.BottomLeft, rectCopy.BottomRight, rectCopy.TopLeft, rectCopy.TopRight }); } else { //add in the points from the convex hull for (int i = 0; i < runOutline.Count; i++) { var point = runOutline[i] + displacementVector + new Vector(0.0, myTextLine.Baseline); point.X += advanceWidths; runOutline[i] = point; } outline.AddRange(runOutline); } advanceWidths += currentRun.AdvanceWidths.Sum(); } _sortedOutline = (from Point p in outline orderby p.X ascending, p.Y descending select p).ToList(); Hull = Geometry <Point> .GetHull(_sortedOutline, p => p); // Diag: Show Hulls or Atom centres #if DEBUG #if SHOWHULLS dc.DrawGeometry(null, new Pen(Brushes.GreenYellow, thickness: 1), HullGeometry); #endif #if SHOWATOMCENTRES dc.DrawEllipse(Brushes.Red, null, ParentAtom.Position, 5, 5); #endif #endif // End Diag dc.Close(); } } } }
/// <summary> /// When overriden in a class, this method allows the execution of code whenever the element has been rendered /// </summary> ///<param name="drawingContext">The <see cref="DrawingContext"/> in which the element has been rendered</param> protected override void OnRender(DrawingContext drawingContext) { if (this.Background != null) { drawingContext.DrawRectangle(this.RenderTarget, Thickness.Empty, this.Background, null); } foreach (UIElement element in this.Children) { element.Render(drawingContext); } }
/// <summary> /// GetPointsAtMiddleSegment /// </summary> internal void GetPointsAtMiddleSegment(StrokeNode previous, double angleBetweenNodes, List <Point> abPoints, List <Point> dcPoints, out bool missingIntersection #if DEBUG_RENDERING_FEEDBACK , DrawingContext debugDC, double feedbackSize, bool showFeedback #endif ) { missingIntersection = false; if (IsValid && previous.IsValid) { Quad quad1 = previous.ConnectingQuad; if (!quad1.IsEmpty) { Quad quad2 = ConnectingQuad; if (!quad2.IsEmpty) { if (IsEllipse) { Rect node1Bounds = _operations.GetNodeBounds(previous._lastNode); Rect node2Bounds = _operations.GetNodeBounds(_lastNode); Rect node3Bounds = _operations.GetNodeBounds(_thisNode); #if DEBUG_RENDERING_FEEDBACK if (showFeedback) { debugDC.DrawEllipse(null, new Pen(Brushes.Pink, feedbackSize / 2), _lastNode.Position, node2Bounds.Width / 2, node2Bounds.Height / 2); } #endif if (angleBetweenNodes == 0.0d || ((quad1.B == quad2.A) && (quad1.C == quad2.D))) { //quads connections are the same, just add them abPoints.Add(quad1.B); dcPoints.Add(quad1.C); #if DEBUG_RENDERING_FEEDBACK if (showFeedback) { debugDC.DrawEllipse(Brushes.Green, null, quad1.B, feedbackSize, feedbackSize); debugDC.DrawEllipse(Brushes.Yellow, null, quad1.C, feedbackSize, feedbackSize); } #endif } else if (angleBetweenNodes > 0.0) { //the stroke angled towards the AB side //this part is easy if (quad1.B == quad2.A) { abPoints.Add(quad1.B); #if DEBUG_RENDERING_FEEDBACK if (showFeedback) { debugDC.DrawEllipse(Brushes.Green, null, quad1.B, feedbackSize, feedbackSize); } #endif } else { Point intersection = GetIntersection(quad1.A, quad1.B, quad2.A, quad2.B); Rect union = Rect.Union(node1Bounds, node2Bounds); union.Inflate(1.0, 1.0); //make sure we're not off in space #if DEBUG_RENDERING_FEEDBACK if (showFeedback) { debugDC.DrawEllipse(Brushes.Green, null, quad1.B, feedbackSize * 1.5, feedbackSize * 1.5); debugDC.DrawEllipse(Brushes.Red, null, quad2.A, feedbackSize, feedbackSize); } #endif if (union.Contains(intersection)) { abPoints.Add(intersection); #if DEBUG_RENDERING_FEEDBACK if (showFeedback) { debugDC.DrawEllipse(Brushes.Orange, null, intersection, feedbackSize, feedbackSize); } #endif } else { //if we missed the intersection we'll need to close the stroke segment //this work is done in StrokeRenderer missingIntersection = true; return; //we're done. } } if (quad1.C == quad2.D) { dcPoints.Add(quad1.C); #if DEBUG_RENDERING_FEEDBACK if (showFeedback) { debugDC.DrawEllipse(Brushes.Yellow, null, quad1.C, feedbackSize, feedbackSize); } #endif } else { //add instructions to arc from quad1.C to quad2.D in reverse order (since we walk this array backwards to render) dcPoints.Add(quad1.C); dcPoints.Add(new Point(node2Bounds.Width, node2Bounds.Height)); dcPoints.Add(StrokeRenderer.ArcToMarker); dcPoints.Add(quad2.D); #if DEBUG_RENDERING_FEEDBACK if (showFeedback) { debugDC.DrawEllipse(Brushes.Yellow, null, quad1.C, feedbackSize, feedbackSize); debugDC.DrawEllipse(Brushes.Blue, null, quad2.D, feedbackSize, feedbackSize); } #endif } } else { //the stroke angled towards the CD side //this part is easy if (quad1.C == quad2.D) { dcPoints.Add(quad1.C); #if DEBUG_RENDERING_FEEDBACK if (showFeedback) { debugDC.DrawEllipse(Brushes.Yellow, null, quad1.C, feedbackSize, feedbackSize); } #endif } else { Point intersection = GetIntersection(quad1.D, quad1.C, quad2.D, quad2.C); Rect union = Rect.Union(node1Bounds, node2Bounds); union.Inflate(1.0, 1.0); //make sure we're not off in space #if DEBUG_RENDERING_FEEDBACK if (showFeedback) { debugDC.DrawEllipse(Brushes.Yellow, null, quad1.C, feedbackSize * 1.5, feedbackSize * 1.5); debugDC.DrawEllipse(Brushes.Blue, null, quad2.D, feedbackSize, feedbackSize); } #endif if (union.Contains(intersection)) { dcPoints.Add(intersection); #if DEBUG_RENDERING_FEEDBACK if (showFeedback) { debugDC.DrawEllipse(Brushes.Orange, null, intersection, feedbackSize, feedbackSize); } #endif } else { //if we missed the intersection we'll need to close the stroke segment //this work is done in StrokeRenderer missingIntersection = true; return; //we're done. } } if (quad1.B == quad2.A) { abPoints.Add(quad1.B); #if DEBUG_RENDERING_FEEDBACK if (showFeedback) { debugDC.DrawEllipse(Brushes.Green, null, quad1.B, feedbackSize, feedbackSize); } #endif } else { //we need to arc between quad1.B and quad2.A along node2 abPoints.Add(quad1.B); abPoints.Add(StrokeRenderer.ArcToMarker); abPoints.Add(new Point(node2Bounds.Width, node2Bounds.Height)); abPoints.Add(quad2.A); #if DEBUG_RENDERING_FEEDBACK if (showFeedback) { debugDC.DrawEllipse(Brushes.Green, null, quad1.B, feedbackSize, feedbackSize); debugDC.DrawEllipse(Brushes.Red, null, quad2.A, feedbackSize, feedbackSize); } #endif } } } else { //rectangle int indexA = -1; int indexB = -1; int indexC = -1; int indexD = -1; Vector[] vertices = _operations.GetVertices(); double pressureFactor = _lastNode.PressureFactor; for (int i = 0; i < vertices.Length; i++) { Point point = _lastNode.Position + (vertices[i % vertices.Length] * pressureFactor); if (point == quad2.A) { indexA = i; } if (point == quad1.B) { indexB = i; } if (point == quad1.C) { indexC = i; } if (point == quad2.D) { indexD = i; } } if (indexA == -1 || indexB == -1 || indexC == -1 || indexD == -1) { Debug.Assert(false, "Couldn't find all 4 indexes in StrokeNodeOperations.GetPointsAtMiddleSegment"); return; } #if DEBUG_RENDERING_FEEDBACK if (showFeedback) { debugDC.DrawRectangle(null, new Pen(Brushes.Pink, feedbackSize / 2), _operations.GetNodeBounds(_lastNode)); debugDC.DrawEllipse(Brushes.Red, null, quad2.A, feedbackSize, feedbackSize); debugDC.DrawEllipse(Brushes.Green, null, quad1.B, feedbackSize, feedbackSize); debugDC.DrawEllipse(Brushes.Yellow, null, quad1.C, feedbackSize, feedbackSize); debugDC.DrawEllipse(Brushes.Blue, null, quad2.D, feedbackSize, feedbackSize); } #endif Rect node3Rect = _operations.GetNodeBounds(_thisNode); //take care of a-b first if (indexA == indexB) { //quad connection is the same, just add it if (!node3Rect.Contains(quad1.B)) { abPoints.Add(quad1.B); } } else if ((indexA == 0 && indexB == 3) || ((indexA != 3 || indexB != 0) && (indexA > indexB))) { if (!node3Rect.Contains(quad1.B)) { abPoints.Add(quad1.B); } if (!node3Rect.Contains(quad2.A)) { abPoints.Add(quad2.A); } } else { Point intersection = GetIntersection(quad1.A, quad1.B, quad2.A, quad2.B); Rect node12 = Rect.Union(_operations.GetNodeBounds(previous._lastNode), _operations.GetNodeBounds(_lastNode)); node12.Inflate(1.0, 1.0); //make sure we're not off in space if (node12.Contains(intersection)) { abPoints.Add(intersection); #if DEBUG_RENDERING_FEEDBACK if (showFeedback) { debugDC.DrawEllipse(Brushes.Orange, null, intersection, feedbackSize, feedbackSize * 1.5); } #endif } else { //if we missed the intersection we'll need to close the stroke segment //this work is done in StrokeRenderer. missingIntersection = true; return; //we're done. } } // now take care of c-d. if (indexC == indexD) { //quad connection is the same, just add it if (!node3Rect.Contains(quad1.C)) { dcPoints.Add(quad1.C); } } else if ((indexC == 0 && indexD == 3) || ((indexC != 3 || indexD != 0) && (indexC > indexD))) { if (!node3Rect.Contains(quad1.C)) { dcPoints.Add(quad1.C); } if (!node3Rect.Contains(quad2.D)) { dcPoints.Add(quad2.D); } } else { Point intersection = GetIntersection(quad1.D, quad1.C, quad2.D, quad2.C); Rect node12 = Rect.Union(_operations.GetNodeBounds(previous._lastNode), _operations.GetNodeBounds(_lastNode)); node12.Inflate(1.0, 1.0); //make sure we're not off in space if (node12.Contains(intersection)) { dcPoints.Add(intersection); #if DEBUG_RENDERING_FEEDBACK if (showFeedback) { debugDC.DrawEllipse(Brushes.Orange, null, intersection, feedbackSize, feedbackSize * 1.5); } #endif } else { //if we missed the intersection we'll need to close the stroke segment //this work is done in StrokeRenderer. missingIntersection = true; return; //we're done. } } } } } } }
/// <summary> /// GetPointsAtEndOfSegment /// </summary> internal void GetPointsAtEndOfSegment(List <Point> abPoints, List <Point> dcPoints #if DEBUG_RENDERING_FEEDBACK , DrawingContext debugDC, double feedbackSize, bool showFeedback #endif ) { if (IsValid) { Quad quad = ConnectingQuad; if (IsEllipse) { Rect bounds = GetBounds(); //add instructions to arc from D to A abPoints.Add(quad.B); abPoints.Add(StrokeRenderer.ArcToMarker); abPoints.Add(new Point(bounds.Width, bounds.Height)); abPoints.Add(quad.C); //don't add to the dc points #if DEBUG_RENDERING_FEEDBACK if (showFeedback) { debugDC.DrawEllipse(null, new Pen(Brushes.Pink, feedbackSize / 2), _thisNode.Position, bounds.Width / 2, bounds.Height / 2); debugDC.DrawEllipse(Brushes.Green, null, quad.B, feedbackSize, feedbackSize); debugDC.DrawEllipse(Brushes.Yellow, null, quad.C, feedbackSize, feedbackSize); } #endif } else { #if DEBUG_RENDERING_FEEDBACK if (showFeedback) { debugDC.DrawRectangle(null, new Pen(Brushes.Pink, feedbackSize / 2), GetBounds()); } #endif //we're interested in the B, C points as well as the //nodecountour points between them double pressureFactor = _thisNode.PressureFactor; Vector[] vertices = _operations.GetVertices(); int maxCount = vertices.Length * 2; int i = 0; for (; i < maxCount; i++) { //look for the d point first Point point = _thisNode.Position + (vertices[i % vertices.Length] * pressureFactor); if (point == quad.B) { abPoints.Add(quad.B); #if DEBUG_RENDERING_FEEDBACK if (showFeedback) { debugDC.DrawEllipse(Brushes.Green, null, point, feedbackSize, feedbackSize); } #endif break; } } if (i == maxCount) { Debug.Assert(false, "StrokeNodeOperations.GetPointsAtEndOfSegment failed to find the B position"); //we didn't find the d point, return return; } //now look for the C position //advance i i++; for (int j = 0; i < maxCount && j < vertices.Length; i++, j++) { //look for the c point last Point point = _thisNode.Position + (vertices[i % vertices.Length] * pressureFactor); if (point == quad.C) { break; } //only add to ab if we didn't find C abPoints.Add(point); #if DEBUG_RENDERING_FEEDBACK if (showFeedback) { debugDC.DrawEllipse(Brushes.Wheat, null, quad.C, feedbackSize, feedbackSize); } #endif } //finally, add the D point dcPoints.Add(quad.C); #if DEBUG_RENDERING_FEEDBACK if (showFeedback) { debugDC.DrawEllipse(Brushes.Yellow, null, quad.C, feedbackSize, feedbackSize); } #endif } } }
///// <summary> ///// IsPointWithinRectOrEllipse ///// </summary> //internal bool IsPointWithinRectOrEllipse(Point point, double xRadiusOrHalfWidth, double yRadiusOrHalfHeight, Point center, bool isEllipse) //{ // if (isEllipse) // { // //determine what delta is required to move the rect to be // //centered at 0,0 // double xDelta = center.X + xRadiusOrHalfWidth; // double yDelta = center.Y + yRadiusOrHalfHeight; // //offset the point by that delta // point.X -= xDelta; // point.Y -= yDelta; // //formula for ellipse is x^2/a^2 + y^2/b^2 = 1 // double a = xRadiusOrHalfWidth; // double b = yRadiusOrHalfHeight; // double res = (((point.X * point.X) / (a * a)) + // ((point.Y * point.Y) / (b * b))); // if (res <= 1) // { // return true; // } // return false; // } // else // { // if (point.X >= (center.X - xRadiusOrHalfWidth) && // point.X <= (center.X + xRadiusOrHalfWidth) && // point.Y >= (center.Y - yRadiusOrHalfHeight) && // point.Y <= (center.Y + yRadiusOrHalfHeight)) // { // return true; // } // return false; // } //} /// <summary> /// GetPointsAtStartOfSegment /// </summary> internal void GetPointsAtStartOfSegment(List <Point> abPoints, List <Point> dcPoints #if DEBUG_RENDERING_FEEDBACK , DrawingContext debugDC, double feedbackSize, bool showFeedback #endif ) { if (IsValid) { Quad quad = ConnectingQuad; if (IsEllipse) { Rect startNodeBounds = _operations.GetNodeBounds(_lastNode); //add instructions to arc from D to A abPoints.Add(quad.D); abPoints.Add(StrokeRenderer.ArcToMarker); abPoints.Add(new Point(startNodeBounds.Width, startNodeBounds.Height)); abPoints.Add(quad.A); //simply start at D dcPoints.Add(quad.D); #if DEBUG_RENDERING_FEEDBACK if (showFeedback) { debugDC.DrawEllipse(null, new Pen(Brushes.Pink, feedbackSize / 2), _lastNode.Position, startNodeBounds.Width / 2, startNodeBounds.Height / 2); debugDC.DrawEllipse(Brushes.Red, null, quad.A, feedbackSize, feedbackSize); debugDC.DrawEllipse(Brushes.Blue, null, quad.D, feedbackSize, feedbackSize); } #endif } else { //we're interested in the A, D points as well as the //nodecountour points between them Rect endNodeRect = _operations.GetNodeBounds(_thisNode); #if DEBUG_RENDERING_FEEDBACK if (showFeedback) { debugDC.DrawRectangle(null, new Pen(Brushes.Pink, feedbackSize / 2), _operations.GetNodeBounds(_lastNode)); } #endif Vector[] vertices = _operations.GetVertices(); double pressureFactor = _lastNode.PressureFactor; int maxCount = vertices.Length * 2; int i = 0; bool dIsInEndNode = true; for (; i < maxCount; i++) { //look for the d point first Point point = _lastNode.Position + (vertices[i % vertices.Length] * pressureFactor); if (point == quad.D) { //ab always starts with the D position (only add if it's not in endNode's bounds) if (!endNodeRect.Contains(quad.D)) { dIsInEndNode = false; abPoints.Add(quad.D); dcPoints.Add(quad.D); } #if DEBUG_RENDERING_FEEDBACK if (showFeedback) { debugDC.DrawEllipse(Brushes.Blue, null, quad.D, feedbackSize, feedbackSize); } #endif break; } } if (i == maxCount) { Debug.Assert(false, "StrokeNodeOperations.GetPointsAtStartOfSegment failed to find the D position"); //we didn't find the d point, return return; } //now look for the A position //advance i i++; for (int j = 0; i < maxCount && j < vertices.Length; i++, j++) { //look for the A point now Point point = _lastNode.Position + (vertices[i % vertices.Length] * pressureFactor); //add everything in between to ab as long as it's not already in endNode's bounds if (!endNodeRect.Contains(point)) { abPoints.Add(point); #if DEBUG_RENDERING_FEEDBACK if (showFeedback) { debugDC.DrawEllipse(Brushes.Wheat, null, point, feedbackSize, feedbackSize); } #endif } if (dIsInEndNode) { Debug.Assert(!endNodeRect.Contains(point)); //add the first point after d, clockwise dIsInEndNode = false; dcPoints.Add(point); } if (point == quad.A) { #if DEBUG_RENDERING_FEEDBACK if (showFeedback) { debugDC.DrawEllipse(Brushes.Red, null, point, feedbackSize, feedbackSize); } #endif break; } } } } }
protected override void OnRender(DrawingContext dc) { dc.DrawRectangle(Background, null, new Rect(RenderSize)); this.VisualTextRenderingMode = TextRenderingMode.ClearType; this.VisualTextHintingMode = TextHintingMode.Fixed; if (Items == null) { return; } Typeface typefaceNormal = null; Typeface typefaceTitle = null; GlyphTypeface glyphTypefaceNormal = null; GlyphTypeface glyphTypefaceTitle = null; try { if (Settings.Instance.FontName.Length > 0) { typefaceNormal = new Typeface(new FontFamily(Settings.Instance.FontName), FontStyles.Normal, FontWeights.Normal, FontStretches.Normal); } if (Settings.Instance.FontNameTitle.Length > 0) { if (Settings.Instance.FontBoldTitle == true) { typefaceTitle = new Typeface(new FontFamily(Settings.Instance.FontNameTitle), FontStyles.Normal, FontWeights.Bold, FontStretches.Normal); } else { typefaceTitle = new Typeface(new FontFamily(Settings.Instance.FontNameTitle), FontStyles.Normal, FontWeights.Normal, FontStretches.Normal); } } if (!typefaceNormal.TryGetGlyphTypeface(out glyphTypefaceNormal)) { typefaceNormal = null; } if (!typefaceTitle.TryGetGlyphTypeface(out glyphTypefaceTitle)) { typefaceTitle = null; } if (typefaceNormal == null) { typefaceNormal = new Typeface(new FontFamily("MS UI Gothic"), FontStyles.Normal, FontWeights.Normal, FontStretches.Normal); if (!typefaceNormal.TryGetGlyphTypeface(out glyphTypefaceNormal)) { MessageBox.Show("フォント指定が不正です"); return; } } if (typefaceTitle == null) { typefaceTitle = new Typeface(new FontFamily("MS UI Gothic"), FontStyles.Normal, FontWeights.Bold, FontStretches.Normal); if (!typefaceTitle.TryGetGlyphTypeface(out glyphTypefaceTitle)) { MessageBox.Show("フォント指定が不正です"); return; } } } catch (Exception ex) { MessageBox.Show(ex.Message + "\r\n" + ex.StackTrace); } try { double sizeNormal = Settings.Instance.FontSize; double sizeTitle = Settings.Instance.FontSizeTitle; foreach (ReserveViewItem info in Items) { dc.DrawRectangle(Brushes.LightGray, null, new Rect(info.LeftPos, info.TopPos, info.Width, info.Height)); if (info.Height > 2) { SolidColorBrush color = Brushes.White; if (info.ReserveInfo.OverlapMode == 1) { color = Brushes.Yellow; //color = CommonManager.Instance.CustContentColorList[0x14]; } dc.DrawRectangle(color, null, new Rect(info.LeftPos + 1, info.TopPos + 1, info.Width - 2, info.Height - 2)); if (info.Height < 4 + sizeTitle + 2) { //高さ足りない info.TitleDrawErr = true; continue; } double totalHeight = 0; //分 string min; min = info.ReserveInfo.StartTime.Minute.ToString("d02") + " "; double useHeight = 0; if (RenderText(min, dc, glyphTypefaceNormal, sizeNormal, info.Width - 4, info.Height - 4, info.LeftPos, info.TopPos, ref useHeight) == false) { info.TitleDrawErr = true; continue; } double widthOffset = sizeNormal * 2; //サービス名 if (info.ReserveInfo.StationName.Length > 0) { String serviceName = info.ReserveInfo.StationName; if (0x7880 <= info.ReserveInfo.OriginalNetworkID && info.ReserveInfo.OriginalNetworkID <= 0x7FE8) { serviceName += " (地デジ)"; } else if (info.ReserveInfo.OriginalNetworkID == 0x0004) { serviceName += " (BS)"; } else if (info.ReserveInfo.OriginalNetworkID == 0x0006) { serviceName += " (CS1)"; } else if (info.ReserveInfo.OriginalNetworkID == 0x0007) { serviceName += " (CS2)"; } else { serviceName += " (その他)"; } if (RenderText(serviceName, dc, glyphTypefaceTitle, sizeTitle, info.Width - 6 - widthOffset, info.Height - 6 - totalHeight, info.LeftPos + widthOffset, info.TopPos + totalHeight, ref useHeight) == false) { info.TitleDrawErr = true; continue; } totalHeight += useHeight + (sizeNormal / 2); } widthOffset = 2; //番組名 if (info.ReserveInfo.Title.Length > 0) { if (RenderText(info.ReserveInfo.Title, dc, glyphTypefaceNormal, sizeNormal, info.Width - 6 - widthOffset, info.Height - 6 - totalHeight, info.LeftPos + widthOffset, info.TopPos + totalHeight, ref useHeight) == false) { info.TitleDrawErr = true; continue; } totalHeight += useHeight + sizeNormal; } } } } catch (Exception ex) { MessageBox.Show(ex.Message + "\r\n" + ex.StackTrace); } }
public override void Drawing(DrawingContext drawingContext) { Point loca = Coordinate.CoordinateTransport(new Point(this.X, this.Y), this.Parent.GlobalCoordinate, Coordinate.BaseCoornidate); drawingContext.DrawRectangle(System.Windows.Media.Brushes.Black, new Pen(Brushes.White, 1), new Rect(loca.X - this.Size / 2, loca.Y - this.Size / 2, this.Size, this.Size)); }
protected override void OnRender(DrawingContext drawingContext) { drawingContext.DrawRectangle(null, _pen, this._bounds); }
/// <summary> /// 十字线末端显示数据 /// </summary> /// <param name="drawingContext"></param> /// <param name="labelcontent"></param> /// <param name="location"></param> private void DrawingText(DrawingContext drawingContext, string labelcontent, Point location, Size rectsize) { drawingContext.DrawRectangle(Brushes.Blue, BlackPen, new Rect(location, rectsize)); drawingContext.DrawText(new FormattedText(labelcontent, CultureInfo.CurrentCulture, FlowDirection.LeftToRight, new Typeface("Tahoma"), 14, Brushes.White), location); }
protected override void OnRender(DrawingContext drawingContext) { drawingContext.DrawRectangle( this.Brush, this.Pen, new Rect(10, 10, 180, 180.5)); }
protected override void OnRender(DrawingContext drawingContext) { Rect fullRect = new Rect(new Point(), new Size(ActualWidth, ActualHeight)); drawingContext.PushClip(new RectangleGeometry(fullRect)); drawingContext.DrawRectangle(Background, null, fullRect); Pen linePen = new Pen(Brushes.White, 3); //drawingContext.DrawLine(linePen, new Point(0, ActualHeight / 2), new Point(ActualWidth, ActualHeight / 2)); drawingContext.DrawLine(new Pen(Brushes.Red, 11), new Point(Midpoint * ActualWidth, 0), new Point(Midpoint * ActualWidth, ActualHeight)); if (Timeline != null) { double timeFrom = _progress - Midpoint * TotalDisplayedDuration; double timeTo = _progress + (1 - Midpoint) * TotalDisplayedDuration; double position = Math.Floor(timeFrom); List <double> beatPositions = new List <double>(); while (position < timeTo) { BeatGroup group = Timeline.FindActiveGroup(position); if (group == null) { group = Timeline.FindNextGroup(position); if (group != null) { position = group.Start; } } if (group == null) { break; } position = group.FindStartingPoint(position); while (position < group.End && position < timeTo) { foreach (double beat in group.Pattern.BeatPositions) { double relativePosition = (((beat * group.ActualPatternDuration) + position - timeFrom) / (timeTo - timeFrom)); beatPositions.Add(relativePosition); } position += group.ActualPatternDuration; } } const double safeSpace = 30; double y = ActualHeight / 2.0; if (_simpleRendering) { DrawLine(drawingContext, Colors.Red, new Point(-safeSpace, y), new Point(ActualWidth + safeSpace, y)); foreach (double pos in beatPositions) { DrawLine(drawingContext, Colors.Lime, new Point(pos * ActualWidth, -5), new Point(pos * ActualWidth, ActualHeight + 5)); } } else { PathGeometry geometry = new PathGeometry(); if (beatPositions.Count > 0) { double start = Math.Min(0, beatPositions.First()); double end = Math.Max(1, beatPositions.Last()); PathFigure figure = new PathFigure { StartPoint = new Point(start * ActualWidth - safeSpace, y) }; geometry.Figures.Add(figure); foreach (double beatPosition in beatPositions) { AppendSwiggely(figure, new Point(beatPosition * ActualWidth, y)); } figure.Segments.Add(new LineSegment(new Point(end * ActualWidth + safeSpace, y), true)); } else { geometry.Figures.Add(new PathFigure(new Point(-safeSpace, y), new[] { new LineSegment(new Point(ActualWidth + safeSpace, y), true) }, false)); } drawingContext.DrawGeometry(null, new Pen(new SolidColorBrush(Colors.Red) { Opacity = 0.5 }, 4) { LineJoin = PenLineJoin.Round }, geometry); drawingContext.DrawGeometry(null, new Pen(new SolidColorBrush(Colors.White) { Opacity = 1.0 }, 2) { LineJoin = PenLineJoin.Round }, geometry); } } drawingContext.Pop(); }
private void bodyFrameReader_FrameArrived(object sender, BodyFrameArrivedEventArgs e) { bool dataReceived = false; using (BodyFrame bodyFrame = e.FrameReference.AcquireFrame()) { if (bodyFrame != null) { if (this.bodies == null) { this.bodies = new Body[bodyFrame.BodyCount]; } bodyFrame.GetAndRefreshBodyData(this.bodies); dataReceived = true; } } if (dataReceived) { using (DrawingContext dc = this.bodyDrawingGroup.Open()) { // Draw a transparent background to set the render size dc.DrawRectangle(Brushes.Black, null, new Rect(0.0, 0.0, this.colorFrameDescription.Width, this.colorFrameDescription.Height)); // prevent drawing outside of our render area bodyDrawingGroup.ClipGeometry = new RectangleGeometry(new Rect(0.0, 0.0, this.colorFrameDescription.Width, this.colorFrameDescription.Height)); dc.DrawImage(colorBitmap, new Rect(0.0, 0.0, this.colorFrameDescription.Width, this.colorFrameDescription.Height)); //Draw recordState bool record = btn_record.Content.Equals("Stop"); if (record) { dc.DrawRectangle(Brushes.Firebrick, null, new Rect(new Point(80, 80), new Size(80, 80))); dc.DrawText(new FormattedText("Rec", CultureInfo.CurrentUICulture, FlowDirection.LeftToRight, new Typeface("Arial"), 35, Brushes.Black), new Point(90, 95)); } foreach (Body body in this.bodies) { if (body.IsTracked) { leftHandPostition = body.Joints[JointType.HandLeft].Position; rightHandPostition = body.Joints[JointType.HandRight].Position; bool angleMode = radio_angle.IsChecked ?? false; drawUI(body.Joints, dc, angleMode); frameSelector++; if (frameSelector == 2) { // 1) Calculate All Data (angles or distances) var allData = calculateData(body.Joints, angleMode, body.JointOrientations); // 2) Write and draw to UI writeData2Gui(allData, angleMode); // 3) Export Data if activated if (record && sequenceID <= maxTrainData + maxTestData) { //show recorded frames lbl_fpsBody.Content = Convert.ToUInt64(lbl_fpsBody.Content) + 1; writeTrainingData(allData); } frameSelector = 0; } } } } } }
// A common way to implement an adorner's rendering behavior is to override the OnRender // method, which is called by the layout system as part of a rendering pass. /// <summary> /// Paints the highlight. /// </summary> protected override void OnRender(DrawingContext drawingContext) { //// Some arbitrary drawing implements. /* this is a nice shortcut but it means we can't set yPos, which is used by scroll highlighter * int firstline = tb.GetFirstVisibleLineIndex(); * if (firstline == -1) { OnRenderImpossible(); return; } * int lastline = tb.GetLastVisibleLineIndex(); * if (lastline == -1) { OnRenderImpossible(); return; } * try * { * int charline = tb.GetLineIndexFromCharacterIndex(start); * if (charline == -1) { OnRenderImpossible(); return; } * if (charline < firstline - 1 || charline > lastline + 1) return; * } * catch (ArgumentOutOfRangeException) { OnRenderImpossible(); return; } */ //drawingContext.PushClip(new RectangleGeometry(new Rect(0, 0, this.AdornedElement.RenderSize.Width, this.AdornedElement.RenderSize.Height))); var leftRectangle = tb.GetRectFromCharacterIndex(start); var rightRectangle = tb.GetRectFromCharacterIndex(start + length); if (Double.IsInfinity(leftRectangle.X)) { OnRenderImpossible(); } yPos = leftRectangle.Top; AdjustRectanglesToView(ref leftRectangle, ref rightRectangle, this.AdornedElement.RenderSize.Height - horizontalScrollBarHeight); // AdjustRectanglesToView(ref leftRectangle, ref rightRectangle, AdornedElement.RenderSize.Height - SystemParameters.ScrollHeight); if (leftRectangle.Top > 1 && rightRectangle.Y > 1 && leftRectangle.Top < (AdornedElement.RenderSize.Height - horizontalScrollBarHeight) && leftRectangle.Left > 1 && rightRectangle.Right > 1 && leftRectangle.Left < (AdornedElement.RenderSize.Width - horizontalScrollBarHeight) //assume vertical scrollbar is as wide as horiz scroll is high ) { if (rightRectangle.Left > AdornedElement.RenderSize.Width - horizontalScrollBarHeight - 1)//if it ends to the right { rightRectangle.X = AdornedElement.RenderSize.Width - horizontalScrollBarHeight - 1; } isInViewport = true; if (RoughlyTheSame(leftRectangle.Top, rightRectangle.Top)) { //notsplit over more than 1 line var rect = new Rect(leftRectangle.TopLeft, rightRectangle.BottomRight); rect.Inflate(1, 1); drawingContext.DrawRectangle(renderBrush, null, rect); } else { if (leftRectangle != Rect.Empty && rightRectangle != Rect.Empty) { //paint as 3 rects //r1 is top line from word to end of line //r2 is start of line to end of line, between first line and last line //r3 is last line from start of line to end of word //we need to figure out the X coords of the start of the line and end of the line Rect[] points = FindStartEndOfVisualLineRects(start, leftRectangle); HighlightAdorner.DrawMultiLine(drawingContext, renderBrush, renderPen, ref leftRectangle, ref rightRectangle, points); } } } else { isInViewport = false; } //drawingContext.Pop(); }
private async void PhotoOnload() { string filePath = @"C:\Users\Public\Pictures\tmp_face.png"; // сохранить фото по пути filePath PngBitmapEncoder encoder = new PngBitmapEncoder(); encoder.Frames.Add(BitmapFrame.Create((BitmapSource)ImageWebcamFrame.Source)); using (FileStream fileStream = new FileStream(filePath, FileMode.Create)) { encoder.Save(fileStream); } Uri fileUri = new Uri(filePath); BitmapImage bitmapSource = new BitmapImage(); bitmapSource.BeginInit(); bitmapSource.CacheOption = BitmapCacheOption.None; bitmapSource.UriSource = fileUri; bitmapSource.EndInit(); ImageWebcamFrame.Source = bitmapSource; // передать путь в функцию faceList = await UploadAndDetectFaces(filePath); if (faceList.Count > 0) { // Prepare to draw rectangles around the faces. DrawingVisual visual = new DrawingVisual(); DrawingContext drawingContext = visual.RenderOpen(); drawingContext.DrawImage(bitmapSource, new Rect(0, 0, bitmapSource.Width, bitmapSource.Height)); double dpi = bitmapSource.DpiX; // Some images don't contain dpi info. resizeFactor = (dpi == 0) ? 1 : 96 / dpi; faceDescriptions = new String[faceList.Count]; for (int i = 0; i < faceList.Count; ++i) { DetectedFace face = faceList[i]; // Draw a rectangle on the face. drawingContext.DrawRectangle( Brushes.Transparent, new Pen(Brushes.Red, 2), new Rect( face.FaceRectangle.Left * resizeFactor, face.FaceRectangle.Top * resizeFactor, face.FaceRectangle.Width * resizeFactor, face.FaceRectangle.Height * resizeFactor ) ); } drawingContext.Close(); // Display the image with the rectangle around the face. RenderTargetBitmap faceWithRectBitmap = new RenderTargetBitmap( (int)(bitmapSource.PixelWidth * resizeFactor), (int)(bitmapSource.PixelHeight * resizeFactor), 96, 96, PixelFormats.Pbgra32); faceWithRectBitmap.Render(visual); ImageWebcamFrame.Source = faceWithRectBitmap; } }
public override void Render(DrawingContext context) { if (Rows == null) { return; } var font = new Typeface(TextBlock.GetFontFamily(this)); var actualWidth = Bounds.Width; var scrollViewer = this.FindAncestorOfType <ScrollViewer>(); // determine the first and last visible row var startIndex = Math.Max(0, (int)(scrollViewer.Offset.Y / RowHeight) - 1); var endIndex = Math.Min(startIndex + scrollViewer.Viewport.Height / RowHeight + 2, Rows.Count); double y = startIndex * RowHeight + DrawingStartOffsetY; bool odd = startIndex % 2 == 0; Span <double> columnWidths = stackalloc double[Columns?.Count ?? 0]; if (Columns != null) { for (int i = 0; i < Columns.Count; i++) { columnWidths[i] = Columns[i].Width; } } var cellDrawer = CustomCellDrawer; // we draw only the visible rows var selectionIterator = MultiSelection.ContainsIterator; for (var index = startIndex; index < endIndex; index++) { var row = Rows[index]; double x = 0; var rowRect = new Rect(0, y, actualWidth, RowHeight); // background bool isSelected = selectionIterator.Contains(index); context.FillRectangle(isSelected ? (SelectedRowBackground) : (odd ? OddRowBackground : EvenRowBackground), rowRect); cellDrawer?.DrawRow(context, row, rowRect); var textColor = isSelected ? FocusTextBrush : TextBrush; int cellIndex = 0; foreach (var cell in row.CellsList) { if (cellIndex >= columnWidths.Length) { return; } if (!IsColumnVisible(cellIndex)) { cellIndex++; continue; } var columnWidth = columnWidths[cellIndex]; // we draw only the visible columns // todo: could be optimized so we don't iterate through all columns when we know we don't need to if (x + columnWidth > scrollViewer.Offset.X && x < scrollViewer.Offset.X + scrollViewer.Viewport.Width) { var rect = new Rect(x, y, Math.Max(0, columnWidth - ColumnSpacing), RowHeight); var rectWidth = rect.Width; var state = context.PushClip(rect); if (cellDrawer == null || !cellDrawer.Draw(context, ref rect, cell)) { var text = cell.ToString(); if (!string.IsNullOrEmpty(text)) { var ft = new FormattedText { Text = text, Constraint = new Size(rect.Width, RowHeight), Typeface = font, FontSize = 12 }; if (Math.Abs(rectWidth - rect.Width) > 0.01) { state.Dispose(); state = context.PushClip(rect); } context.DrawText(textColor, new Point(rect.X + ColumnSpacing, y + RowHeight / 2 - ft.Bounds.Height / 2), ft); } } state.Dispose(); } x += columnWidth; cellIndex++; } y += RowHeight; odd = !odd; } if (IsKeyboardFocusWithin && IsSelectedCellValid && !editor.IsOpened) { context.DrawRectangle(FocusOuterPen, SelectedCellRect, 4); context.DrawRectangle(FocusPen, SelectedCellRect, 4); } RenderHeaders(context); }
public void RenderRectangle(Rect rectangle, Brush foreground) { var scaledRectangle = GeometryHelper.ScaleRectangle(_scale, rectangle); _drawingContext.DrawRectangle(foreground, null, scaledRectangle); }
//------------------------------------------------------ // // Protected Methods // //------------------------------------------------------ #region Protected Methods /// <summary> /// Render override to render the composition adorner here. /// </summary> protected override void OnRender(DrawingContext drawingContext) { // Get the matrix from AdornedElement to the visual parent to get the transformed // start/end point Visual parent2d = VisualTreeHelper.GetParent(this.AdornedElement) as Visual; if (parent2d == null) { return; } GeneralTransform transform = AdornedElement.TransformToAncestor(parent2d); if (transform == null) { return; } // Please note that we do the highlight adornment for the CONVERTED text only // for Simplified Chinese IMEs. Doing this uniformly across all IMEs wasnt possible // because it was noted that some of them (viz. Japanese) werent being consistent // about this attribute. bool isChinesePinyin = chinesePinyin.Equals(InputLanguageManager.Current.CurrentInputLanguage.IetfLanguageTag); // Render the each of the composition string attribute from the attribute ranges. for (int i = 0; i < _attributeRanges.Count; i++) { DoubleCollection dashArray; // Get the composition attribute range from the attribute range lists AttributeRange attributeRange = (AttributeRange)_attributeRanges[i]; // Skip the rendering composition lines if the composition line doesn't exist. if (attributeRange.CompositionLines.Count == 0) { continue; } // Set the line bold and squiggle bool lineBold = attributeRange.TextServicesDisplayAttribute.IsBoldLine ? true : false; bool squiggle = false; bool hasVirtualSelection = (attributeRange.TextServicesDisplayAttribute.AttrInfo & UnsafeNativeMethods.TF_DA_ATTR_INFO.TF_ATTR_TARGET_CONVERTED) != 0; Brush selectionBrush = null; double selectionOpacity = -1; Pen selectionPen = null; if (isChinesePinyin && hasVirtualSelection) { DependencyObject owner = _textView.TextContainer.Parent; selectionBrush = (Brush)owner.GetValue(TextBoxBase.SelectionBrushProperty); selectionOpacity = (double)owner.GetValue(TextBoxBase.SelectionOpacityProperty); } // Set the line height and cluse gap value that base on the ratio of text height double height = attributeRange.Height; double lineHeight = height * (lineBold ? BoldLineHeightRatio : NormalLineHeightRatio); double clauseGap = height * ClauseGapRatio; // Create Pen for drawing the composition lines with the specified line color Pen pen = new Pen(new SolidColorBrush(Colors.Black), lineHeight); // Set the pen style that based on IME's composition line style switch (attributeRange.TextServicesDisplayAttribute.LineStyle) { case UnsafeNativeMethods.TF_DA_LINESTYLE.TF_LS_DOT: // Add the dot length and specify the start/end line cap as the round dashArray = new DoubleCollection(); dashArray.Add(DotLength); dashArray.Add(DotLength); pen.DashStyle = new DashStyle(dashArray, 0); pen.DashCap = System.Windows.Media.PenLineCap.Round; pen.StartLineCap = System.Windows.Media.PenLineCap.Round; pen.EndLineCap = System.Windows.Media.PenLineCap.Round; // Update the line height for the dot line. Dot line will be more thickness than // other line to show it clearly. lineHeight = height * (lineBold ? BoldDotLineHeightRatio : NormalDotLineHeightRatio); break; case UnsafeNativeMethods.TF_DA_LINESTYLE.TF_LS_DASH: double dashLength = height * (lineBold ? BoldDashRatio : NormalDashRatio); double dashGapLength = height * (lineBold ? BoldDashGapRatio : NormalDashGapRatio); // Add the dash and dash gap legth dashArray = new DoubleCollection(); dashArray.Add(dashLength); dashArray.Add(dashGapLength); pen.DashStyle = new DashStyle(dashArray, 0); pen.DashCap = System.Windows.Media.PenLineCap.Round; pen.StartLineCap = System.Windows.Media.PenLineCap.Round; pen.EndLineCap = System.Windows.Media.PenLineCap.Round; break; case UnsafeNativeMethods.TF_DA_LINESTYLE.TF_LS_SOLID: pen.StartLineCap = System.Windows.Media.PenLineCap.Round; pen.EndLineCap = System.Windows.Media.PenLineCap.Round; break; case UnsafeNativeMethods.TF_DA_LINESTYLE.TF_LS_SQUIGGLE: squiggle = true; break; } double halfLineHeight = lineHeight / 2; // Draw the each of the composition line for (int j = 0; j < attributeRange.CompositionLines.Count; j++) { CompositionLine compositionLine = (CompositionLine)attributeRange.CompositionLines[j]; // Get the start/end point for composition adorner. // Currently Text doesn't aware of the spaceroom for the drawing of the composition // adorner(like as normal/bold dot/line/squggle), so we should draw the composition adorners // to the closest area of the bottom text. Point startPoint = new Point(compositionLine.StartPoint.X + clauseGap, compositionLine.StartPoint.Y - halfLineHeight); Point endPoint = new Point(compositionLine.EndPoint.X - clauseGap, compositionLine.EndPoint.Y - halfLineHeight); // Apply composition line color which is actually the foreground of text as well pen.Brush = new SolidColorBrush(compositionLine.LineColor); // Apply matrix to start/end point // REVIEW: if the points can't be transformed, should we not draw anything? transform.TryTransform(startPoint, out startPoint); transform.TryTransform(endPoint, out endPoint); if (isChinesePinyin && hasVirtualSelection) { Rect rect = Rect.Union(compositionLine.StartRect, compositionLine.EndRect); rect = transform.TransformBounds(rect); drawingContext.PushOpacity(selectionOpacity); drawingContext.DrawRectangle(selectionBrush, selectionPen, rect); drawingContext.Pop(); } if (squiggle) { // Draw the squiggle line with using of the PathFigure and DrawGemetry. // We may revisit this logic to render the smooth squiggle line. Point pathPoint = new Point(startPoint.X, startPoint.Y - halfLineHeight); double squiggleGap = halfLineHeight; PathFigure pathFigure = new PathFigure(); pathFigure.StartPoint = pathPoint; int indexPoint = 0; while (indexPoint < ((endPoint.X - startPoint.X) / (squiggleGap))) { if (indexPoint % 4 == 0 || indexPoint % 4 == 3) { pathPoint = new Point(pathPoint.X + squiggleGap, pathPoint.Y + halfLineHeight); pathFigure.Segments.Add(new LineSegment(pathPoint, true)); } else if (indexPoint % 4 == 1 || indexPoint % 4 == 2) { pathPoint = new Point(pathPoint.X + squiggleGap, pathPoint.Y - halfLineHeight); pathFigure.Segments.Add(new LineSegment(pathPoint, true)); } indexPoint++; } PathGeometry pathGeometry = new PathGeometry(); pathGeometry.Figures.Add(pathFigure); // Draw the composition line with the squiggle drawingContext.DrawGeometry(null, pen, pathGeometry); } else { drawingContext.DrawLine(pen, startPoint, endPoint); } } } }
/// <summary> /// Handles the body frame data arriving from the sensor /// </summary> /// <param name="sender">object sending the event</param> /// <param name="e">event arguments</param> private void Reader_FrameArrived(object sender, BodyFrameArrivedEventArgs e) { bool dataReceived = false; using (BodyFrame bodyFrame = e.FrameReference.AcquireFrame()) { if (bodyFrame != null) { if (this.bodies == null) { this.bodies = new Body[bodyFrame.BodyCount]; } // The first time GetAndRefreshBodyData is called, Kinect will allocate each Body in the array. // As long as those body objects are not disposed and not set to null in the array, // those body objects will be re-used. bodyFrame.GetAndRefreshBodyData(this.bodies); dataReceived = true; } } if (dataReceived) { using (DrawingContext dc = this.drawingGroup.Open()) { // Draw a transparent background to set the render size dc.DrawRectangle(Brushes.Black, null, new Rect(0.0, 0.0, this.displayWidth, this.displayHeight)); int penIndex = 0; foreach (Body body in this.bodies) { Pen drawPen = this.bodyColors[penIndex++]; if (body.IsTracked) { this.DrawClippedEdges(body, dc); IReadOnlyDictionary <JointType, Joint> joints = body.Joints; // convert the joint points to depth (display) space Dictionary <JointType, Point> jointPoints = new Dictionary <JointType, Point>(); foreach (JointType jointType in joints.Keys) { // sometimes the depth(Z) of an inferred joint may show as negative // clamp down to 0.1f to prevent coordinatemapper from returning (-Infinity, -Infinity) CameraSpacePoint position = joints[jointType].Position; if (position.Z < 0) { position.Z = InferredZPositionClamp; } DepthSpacePoint depthSpacePoint = this.coordinateMapper.MapCameraPointToDepthSpace(position); jointPoints[jointType] = new Point(depthSpacePoint.X, depthSpacePoint.Y); } this.DrawBody(joints, jointPoints, dc, drawPen); this.DrawHand(body.HandLeftState, jointPoints[JointType.HandLeft], dc); this.DrawHand(body.HandRightState, jointPoints[JointType.HandRight], dc); // Write wrist position and hand orientation if (!this.WriteJoint(body)) { Environment.Exit(0); } } } // prevent drawing outside of our render area this.drawingGroup.ClipGeometry = new RectangleGeometry(new Rect(0.0, 0.0, this.displayWidth, this.displayHeight)); } } }
/// <summary> /// Event handler for Kinect sensor's SkeletonFrameReady event /// </summary> /// <param name="sender">object sending the event</param> /// <param name="e">event arguments</param> private void SensorSkeletonFrameReady(object sender, SkeletonFrameReadyEventArgs e) { Skeleton[] skeletons = new Skeleton[0]; using (SkeletonFrame skeletonFrame = e.OpenSkeletonFrame()) { if (skeletonFrame != null) { skeletons = new Skeleton[skeletonFrame.SkeletonArrayLength]; skeletonFrame.CopySkeletonDataTo(skeletons); } } using (DrawingContext dc = this.drawingGroup.Open()) { // Draw a transparent background to set the render size dc.DrawRectangle(Brushes.Black, null, new Rect(0.0, 0.0, RenderWidth, RenderHeight)); if (skeletons.Count(t => t.TrackingState == SkeletonTrackingState.Tracked) >= 1) { Skeleton player1 = skeletons.First(p => p.TrackingState == SkeletonTrackingState.Tracked); Skeleton player2 = skeletons.Last(p => p.TrackingState == SkeletonTrackingState.Tracked); //Console.WriteLine(player1.Position.Z.ToString()); paddleLeft.MoveTo((RenderHeight / 2 - paddleLeft.h / 2) + (player1.Position.Z - 2) * 500); paddleRight.MoveTo((RenderHeight / 2 - paddleRight.h / 2) + (player2.Position.Z - 2) * 500); //TODO change to player2 } paddleLeft.Draw(dc); paddleRight.Draw(dc); ball.Draw(dc); ball.Move(); ball.DetectCollision(paddleLeft, paddleRight); if (ball.HitRight()) { scoreLeft++; this.ScoreLeft.Text = scoreLeft.ToString(); ball.Spawn(); } if (ball.HitLeft()) { scoreRight++; this.ScoreRight.Text = scoreRight.ToString(); ball.Spawn(); } if (showSkeletons) { foreach (Skeleton skel in skeletons) { //RenderClippedEdges(skel, dc); if (skel.TrackingState == SkeletonTrackingState.Tracked) { this.DrawBonesAndJoints(skel, dc); } else if (skel.TrackingState == SkeletonTrackingState.PositionOnly) { dc.DrawEllipse( this.centerPointBrush, null, this.SkeletonPointToScreen(skel.Position), BodyCenterThickness, BodyCenterThickness); } } } // prevent drawing outside of our render area this.drawingGroup.ClipGeometry = new RectangleGeometry(new Rect(0.0, 0.0, RenderWidth, RenderHeight)); } }
/// <summary> /// Exports the diagram to an image. /// </summary> /// <param name="method">image format</param> /// <param name="filename">file name</param> /// <param name="title">diagram title</param> /// <param name="useFrameAndCaption"></param> public void ExportToImage(EExportToImageMethod method, string filename, string title, bool useFrameAndCaption) { const int bounds = 10; const int textoffset = 20; #if DEBUG Visibility labelVisible = MouseLabel.Visibility; MouseLabel.Visibility = Visibility.Collapsed; #endif if (method == EExportToImageMethod.PNG || method == EExportToImageMethod.PNGClipBoard) { FormattedText titleText = new FormattedText(title, new CultureInfo("en-us"), FlowDirection.LeftToRight, new Typeface("Verdana"), 20, Brushes.Gray); double canvasWidth; double canvasHeight; GetCanvasWidthAndHeight(out canvasWidth, out canvasHeight); RenderTargetBitmap rtb; if (useFrameAndCaption) { rtb = new RenderTargetBitmap((int)(Math.Max(bounds + canvasWidth + bounds, textoffset + titleText.Width + textoffset)), (int)(textoffset + titleText.Height + textoffset + canvasHeight + bounds), 96, 96, PixelFormats.Pbgra32); } else { rtb = new RenderTargetBitmap((int)(canvasWidth), (int)(canvasHeight), 96, 96, PixelFormats.Pbgra32); } this.InvalidateVisual(); DrawingVisual drawingVisual = new DrawingVisual(); DrawingContext drawingContext = drawingVisual.RenderOpen(); drawingContext.DrawRectangle(this.Background, null, new Rect(0, 0, rtb.Width, rtb.Height)); VisualBrush canvasBrush = new VisualBrush(this); canvasBrush.Stretch = Stretch.None; canvasBrush.AlignmentX = 0; canvasBrush.AlignmentY = 0; if (useFrameAndCaption) { Rect rect = new Rect(bounds, textoffset + titleText.Height + textoffset, rtb.Width - 2 * bounds, rtb.Height - bounds - textoffset - titleText.Height - textoffset); drawingContext.DrawRectangle(canvasBrush, new Pen(Brushes.LightGray, 1), rect); drawingContext.DrawText(titleText, new Point(rtb.Width / 2 - titleText.Width / 2, textoffset)); } else { drawingContext.DrawRectangle(canvasBrush, null, new Rect(0, 0, (canvasWidth), (canvasHeight))); } drawingContext.Close(); rtb.Render(drawingVisual); PngBitmapEncoder png = new PngBitmapEncoder(); png.Frames.Add(BitmapFrame.Create(rtb)); if (method == EExportToImageMethod.PNG) { using (Stream stm = File.Create(filename)) { png.Save(stm); } } if (method == EExportToImageMethod.PNGClipBoard) { Clipboard.SetImage(rtb); } } else if (method == EExportToImageMethod.XPS) { { double canvasWidth; double canvasHeight; GetCanvasWidthAndHeight(out canvasWidth, out canvasHeight); // Save current canvas transorm Transform transform = this.LayoutTransform; // Temporarily reset the layout transform before saving this.LayoutTransform = null; // Get the size of the canvas Size size = new Size(canvasWidth, canvasHeight); // Measure and arrange elements this.Measure(size); this.Arrange(new Rect(size)); // Open new package System.IO.Packaging.Package package = System.IO.Packaging.Package.Open(filename, FileMode.Create); // Create new xps document based on the package opened XpsDocument doc = new XpsDocument(package); // Create an instance of XpsDocumentWriter for the document XpsDocumentWriter writer = XpsDocument.CreateXpsDocumentWriter(doc); // Write the canvas (as Visual) to the document writer.Write(this); // Close document doc.Close(); // Close package package.Close(); // Restore previously saved layout this.LayoutTransform = transform; } } #if DEBUG MouseLabel.Visibility = labelVisible; #endif }
/// <summary> /// Handles the body frame data arriving from the sensor /// </summary> /// <param name="sender">object sending the event</param> /// <param name="e">event arguments</param> private void Reader_FrameArrived(object sender, BodyFrameArrivedEventArgs e) { bool dataReceived = false; using (BodyFrame bodyFrame = e.FrameReference.AcquireFrame()) { if (bodyFrame != null) { if (this.bodies == null) { this.bodies = new Body[bodyFrame.BodyCount]; } // The first time GetAndRefreshBodyData is called, Kinect will allocate each Body in the array. // As long as those body objects are not disposed and not set to null in the array, // those body objects will be re-used. bodyFrame.GetAndRefreshBodyData(this.bodies); dataReceived = true; } } if (dataReceived) { using (DrawingContext dc = this.drawingGroup.Open()) { // Draw a transparent background to set the render size dc.DrawRectangle(Brushes.Black, null, new Rect(0.0, 0.0, this.displayWidth, this.displayHeight)); int penIndex = 0; foreach (Body body in this.bodies) { Pen drawPen = this.bodyColors[2]; if (body.IsTracked) { Joint l_shoulder = body.Joints[JointType.ShoulderLeft]; Joint r_shoulder = body.Joints[JointType.ShoulderRight]; Joint elbow = body.Joints[JointType.ElbowRight]; Joint hand = body.Joints[JointType.WristRight]; hand_x = hand.Position.X; hand_y = hand.Position.Y; hand_z = hand.Position.Z; elbow_x = elbow.Position.X; elbow_y = elbow.Position.Y; elbow_z = elbow.Position.Z; r_shoulder_x = r_shoulder.Position.X; r_shoulder_y = r_shoulder.Position.Y; r_shoulder_z = r_shoulder.Position.Z; l_shoulder_x = l_shoulder.Position.X; l_shoulder_y = l_shoulder.Position.Y; l_shoulder_z = l_shoulder.Position.Z; //Vectores v1[0] = (r_shoulder_x - l_shoulder_x); v1[1] = (r_shoulder_y - l_shoulder_y); v1[2] = (r_shoulder_z - l_shoulder_z); v2[0] = (elbow_x - r_shoulder_x); v2[1] = (elbow_y - r_shoulder_y); v2[2] = (elbow_z - r_shoulder_z); v3[0] = (hand_x - elbow_x); v3[1] = (hand_y - elbow_y); v3[2] = (hand_z - elbow_z); Vector vector1 = new Vector(v1[0], v1[1]); Vector vector2 = new Vector(v2[0], v2[1]); Vector vector3 = new Vector(v3[0], v3[1]); //Codo angle_1 = Vector.AngleBetween(vector1, vector2); //Mano angle_2 = Vector.AngleBetween(vector2, vector3); if (angle_1 > 0) { a1_sig = 1; } else { a1_sig = 0; } if (angle_2 > 0) { a2_sig = 1; } else { a2_sig = 0; } if (angle_1 <= -90) { angle_1 = -90; } else if (angle_1 >= -91 && angle_1 < -83) { angle_1 = -90; } else if (angle_1 >= -83 && angle_1 < -76) { angle_1 = -76; } else if (angle_1 >= -75 && angle_1 < -70) { angle_1 = -75; } else if (angle_1 >= -70 && angle_1 < -65) { angle_1 = -70; } else if (angle_1 >= -65 && angle_1 < -60) { angle_1 = -65; } else if (angle_1 >= -60 && angle_1 < -55) { angle_1 = -60; } else if (angle_1 >= -55 && angle_1 < -50) { angle_1 = -55; } else if (angle_1 >= -50 && angle_1 < -45) { angle_1 = -50; } else if (angle_1 >= -45 && angle_1 < -40) { angle_1 = -45; } else if (angle_1 >= -40 && angle_1 < -35) { angle_1 = -40; } else if (angle_1 >= -35 && angle_1 < -30) { angle_1 = -35; } else if (angle_1 >= -30 && angle_1 < -25) { angle_1 = -30; } else if (angle_1 >= -25 && angle_1 < -20) { angle_1 = -25; } else if (angle_1 >= -20 && angle_1 < -15) { angle_1 = -20; } else if (angle_1 >= -15 && angle_1 < -10) { angle_1 = -15; } else if (angle_1 >= -10 && angle_1 < -5) { angle_1 = -10; } else if (angle_1 >= -5 && angle_1 < 0) { angle_1 = -5; } else if (angle_1 >= 0 && angle_1 < 5) { angle_1 = 0; } else if (angle_1 >= 5 && angle_1 < 10) { angle_1 = 5; } else if (angle_1 >= 10 && angle_1 < 15) { angle_1 = 15; } else if (angle_1 >= 15 && angle_1 < 20) { angle_1 = 20; } else if (angle_1 >= 20 && angle_1 < 25) { angle_1 = 25; } else if (angle_1 >= 25 && angle_1 < 30) { angle_1 = 30; } else if (angle_1 >= 30 && angle_1 < 35) { angle_1 = 35; } else if (angle_1 >= 35 && angle_1 < 40) { angle_1 = 40; } else if (angle_1 >= 45 && angle_1 < 50) { angle_1 = 45; } else if (angle_1 >= 50 && angle_1 < 55) { angle_1 = 50; } else if (angle_1 >= 55 && angle_1 < 60) { angle_1 = 55; } else if (angle_1 >= 60 && angle_1 < 65) { angle_1 = 60; } else if (angle_1 >= 65 && angle_1 < 70) { angle_1 = 65; } else if (angle_1 >= 70 && angle_1 < 75) { angle_1 = 70; } else if (angle_1 >= 75 && angle_1 < 80) { angle_1 = 75; } else if (angle_1 >= 80 && angle_1 < 85) { angle_1 = 80; } else if (angle_1 >= 85 && angle_1 < 90) { angle_1 = 85; } else if (angle_1 >= 90) { angle_1 = 90; } //Fuzzy Angle Mano if (angle_2 <= 0) { angle_2 = 0; } else if (angle_2 >= 9 && angle_2 < 18) { angle_2 = 9; } else if (angle_2 >= 18 && angle_2 < 27) { angle_2 = 18; } else if (angle_2 >= 27 && angle_2 < 36) { angle_2 = 27; } else if (angle_2 >= 36 && angle_2 < 45) { angle_2 = 36; } else if (angle_2 >= 45 && angle_2 < 54) { angle_2 = 45; } else if (angle_2 >= 54 && angle_2 < 63) { angle_2 = 54; } else if (angle_2 >= 63 && angle_2 < 72) { angle_2 = 63; } else if (angle_2 >= 72 && angle_2 < 81) { angle_2 = 72; } else if (angle_2 >= 81 && angle_2 < 90) { angle_2 = 81; } else if (angle_2 >= 90 && angle_2 < 99) { angle_2 = 90; } else if (angle_2 >= 99 && angle_2 < 108) { angle_2 = 99; } else if (angle_2 >= 108 && angle_2 < 117) { angle_2 = 108; } else if (angle_2 >= 117 && angle_2 < 126) { angle_2 = 117; } else if (angle_2 >= 126) { angle_2 = 126; } //Codo temp_1 = (Convert.ToInt32(Math.Abs(angle_1))).ToString("D3"); //Mano temp_2 = (Convert.ToInt32(Math.Abs(angle_2))).ToString("D3"); //12345 6 7 8 9 10 11 12 13 14 15 16 17 //#TEXT 0 1 4 A 0 3 6 B 0 C 1 D# this.DrawClippedEdges(body, dc); IReadOnlyDictionary <JointType, Joint> joints = body.Joints; // convert the joint points to depth (display) space Dictionary <JointType, Point> jointPoints = new Dictionary <JointType, Point>(); foreach (JointType jointType in joints.Keys) { // sometimes the depth(Z) of an inferred joint may show as negative // clamp down to 0.1f to prevent coordinatemapper from returning (-Infinity, -Infinity) CameraSpacePoint position = joints[jointType].Position; if (position.Z < 0) { position.Z = InferredZPositionClamp; } DepthSpacePoint depthSpacePoint = this.coordinateMapper.MapCameraPointToDepthSpace(position); jointPoints[jointType] = new Point(depthSpacePoint.X, depthSpacePoint.Y); } this.DrawBody(joints, jointPoints, dc, drawPen); this.DrawHand(body.HandLeftState, jointPoints[JointType.HandLeft], dc); this.DrawHand(body.HandRightState, jointPoints[JointType.HandRight], dc); } } // prevent drawing outside of our render area this.drawingGroup.ClipGeometry = new RectangleGeometry(new Rect(0.0, 0.0, this.displayWidth, this.displayHeight)); } } }
private void DrawScroll(object picture) { WriteableBitmap wbmp = (WriteableBitmap)picture; DrawingVisual drawingVisual = new DrawingVisual(); using (DrawingContext drawingContext = drawingVisual.RenderOpen()) { //Заливка цветом drawingContext.DrawRectangle(Brushes.White, blackPen, new Rect(this._size)); double oy = (this._y / this._k); double ox = this._size.Width / (this._channel.Length - 1) * this._zoom.ZoomX; //Видимая ширина в пикселях int xBaseValue = CommonHelper.CalcBaseXValue(COUNTDOWN_MAX_WIDTH, this._size.Width * this._zoom.ZoomX, this._channel.Length); double yBaseValue = (BASE_HEIGTH / 2.0 + ADDED_HEIGTH) * this._zoom.ZoomY; int startX = (int)Math.Round(((this._channel.Length - 1) / (double)this._zoom.ZoomX * (this._scrollOffset / (double)WorkplaceControl.BASE_CHANGE))); int endX = (int) Math.Round((this._channel.Length - 1) / (double)this._zoom.ZoomX * (1 + this._scrollOffset / (double)WorkplaceControl.BASE_CHANGE)); //Ось Х(Горизонтальные линии) for (int j = -2; j <= 2; j++) { Point p1 = new Point(startX * ox - this._xOffset, oy * j + yBaseValue); Point p2 = new Point(endX * ox - this._xOffset, oy * j + yBaseValue); drawingContext.DrawLine(j == 0 ? blackPen : grayPen, p1, p2); } //Ось Y(Вертикальные линии) for (int i = (startX / xBaseValue) * xBaseValue; i < endX; i += xBaseValue) { Point p1 = new Point(i * ox - this._xOffset, 0); Point p2 = new Point(i * ox - this._xOffset, FULL_HEIGTH * this._zoom.ZoomY); drawingContext.DrawLine(grayPen, p1, p2); } //График(Кривая) double[] values = this._channel.Values(this.CurrentValueType); for (int i = startX; i < endX; i += 1) { Point p1 = new Point(i * ox - this._xOffset, -(values[i] / this._k) + yBaseValue); Point p2 = new Point((i + 1) * ox - this._xOffset, -(values[i + 1] / this._k) + yBaseValue); drawingContext.DrawLine(this.diagramPen, p1, p2); } //Подписи оси оХ for (int i = 0; i < endX; i += xBaseValue) { FormattedText formattedText = new FormattedText( ((i)).ToString(CultureInfo.InvariantCulture), CultureInfo.GetCultureInfo("en-us"), FlowDirection.LeftToRight, new Typeface("Verdana"), 12, Brushes.Black); double xPos = 0; if ((i != 0) || (this._scrollOffset != 0)) { xPos = i * ox - this._xOffset - formattedText.Width / 2; } drawingContext.DrawText(formattedText, new Point(xPos, yBaseValue)); } } RenderTargetBitmap bmp = new RenderTargetBitmap((int)(this._size.Width), (int)this._size.Height, 0, 0, PixelFormats.Pbgra32); bmp.Render(drawingVisual); bmp.Freeze(); uint[] arrBits = new uint[bmp.PixelWidth * bmp.PixelHeight]; bmp.CopyPixels(arrBits, 4 * bmp.PixelWidth, 0); Dispatcher.Invoke(new Action <uint[], WriteableBitmap>(this.DrawComplite), arrBits, wbmp); }
/// <summary> /// When overriden in a class, renders the visual /// </summary> /// <param name="drawingContext">The <see cref="DrawingContext"/> in whihc to render the visual</param> protected override void OnRender(DrawingContext drawingContext) { if (this.Background != null) { drawingContext.DrawRectangle(this.RenderTarget, Thickness.Empty, this.Background, null); } if(this.Child != null) { this.Child.Render(drawingContext); } }
private void DrawTile(DrawingContext context, TrackTile type, int x, int y, Dictionary <TileType, ImageBrush> mapping) { bool left; bool upper; bool lower; bool right; bool upperLeft; bool upperRight; bool lowerLeft; bool lowerRight; if (type == TrackTile.Road) { left = game.Track.GetTileByIndex(x - 1, y).HasFlag(TrackTile.Road); upper = game.Track.GetTileByIndex(x, y - 1).HasFlag(TrackTile.Road); lower = game.Track.GetTileByIndex(x, y + 1).HasFlag(TrackTile.Road); right = game.Track.GetTileByIndex(x + 1, y).HasFlag(TrackTile.Road); upperLeft = game.Track.GetTileByIndex(x - 1, y - 1).HasFlag(TrackTile.Road); upperRight = game.Track.GetTileByIndex(x + 1, y - 1).HasFlag(TrackTile.Road); lowerLeft = game.Track.GetTileByIndex(x - 1, y + 1).HasFlag(TrackTile.Road); lowerRight = game.Track.GetTileByIndex(x + 1, y + 1).HasFlag(TrackTile.Road); } else { left = game.Track.GetTileByIndex(x - 1, y) == type; upper = game.Track.GetTileByIndex(x, y - 1) == type; lower = game.Track.GetTileByIndex(x, y + 1) == type; right = game.Track.GetTileByIndex(x + 1, y) == type; upperLeft = game.Track.GetTileByIndex(x - 1, y - 1) == type; upperRight = game.Track.GetTileByIndex(x + 1, y - 1) == type; lowerLeft = game.Track.GetTileByIndex(x - 1, y + 1) == type; lowerRight = game.Track.GetTileByIndex(x + 1, y + 1) == type; } #region Upper Left ImageBrush cell00 = mapping[TileType.Center]; if (!left) { if (!upper) { // konvexe linke ecke cell00 = mapping[TileType.UpperLeftConvex]; } else { // linke kante cell00 = mapping[TileType.Left]; } } else { if (!upper) { // obere Kante cell00 = mapping[TileType.Upper]; } else if (!upperLeft) { // linke konkave Ecke cell00 = mapping[TileType.UpperLeftConcave]; } } context.DrawRectangle(cell00, null, new Rect(x * Track.CELLSIZE, y * Track.CELLSIZE, Track.CELLSIZE / 2, Track.CELLSIZE / 2)); #endregion #region Upper Right ImageBrush cell10 = mapping[TileType.Center]; if (!right) { if (!upper) { // konvexe linke ecke cell10 = mapping[TileType.UpperRightConvex]; } else { // linke kante cell10 = mapping[TileType.Right]; } } else { if (!upper) { // obere Kante cell10 = mapping[TileType.Upper]; } else if (!upperRight) { // linke konkave Ecke cell10 = mapping[TileType.UpperRightConcave]; } } context.DrawRectangle(cell10, null, new Rect((x * Track.CELLSIZE) + (Track.CELLSIZE / 2), y * Track.CELLSIZE, Track.CELLSIZE / 2, Track.CELLSIZE / 2)); #endregion #region Lower Right ImageBrush cell11 = mapping[TileType.Center]; if (!right) { if (!lower) { // konvexe linke ecke cell11 = mapping[TileType.LowerRightConvex]; } else { // linke kante cell11 = mapping[TileType.Right]; } } else { if (!lower) { // obere Kante cell11 = mapping[TileType.Lower]; } else if (!lowerRight) { // linke konkave Ecke cell11 = mapping[TileType.LowerRightConcave]; } } context.DrawRectangle(cell11, null, new Rect((x * Track.CELLSIZE) + (Track.CELLSIZE / 2), (y * Track.CELLSIZE) + (Track.CELLSIZE / 2), Track.CELLSIZE / 2, Track.CELLSIZE / 2)); #endregion #region Lower Left ImageBrush cell01 = mapping[TileType.Center]; if (!left) { if (!lower) { // konvexe linke ecke cell01 = mapping[TileType.LowerLeftConvex]; } else { // linke kante cell01 = mapping[TileType.Left]; } } else { if (!lower) { // obere Kante cell01 = mapping[TileType.Lower]; } else if (!lowerLeft) { // linke konkave Ecke cell01 = mapping[TileType.LowerLeftConcave]; } } context.DrawRectangle(cell01, null, new Rect(x * Track.CELLSIZE, (y * Track.CELLSIZE) + (Track.CELLSIZE / 2), Track.CELLSIZE / 2, Track.CELLSIZE / 2)); #endregion }
/// <summary> /// When overriden in a class, renders the visual /// </summary> /// <param name="drawingContext">The <see cref="DrawingContext"/> in whihc to render the visual</param> protected override void OnRender(DrawingContext drawingContext) { if(this.Background != null || this.BorderBrush != null) { drawingContext.DrawRectangle(this.RenderTarget, this.BorderThickness, this.Background, this.BorderBrush); } if (this.Child != null) { this.Child.Render(drawingContext); } }
/// <summary> /// Event handler for Kinect sensor's SkeletonFrameReady event /// </summary> /// <param name="sender">object sending the event</param> /// <param name="e">event arguments</param> private void SensorSkeletonFrameReady(object sender, SkeletonFrameReadyEventArgs e) { Skeleton[] skeletons = new Skeleton[0]; using (SkeletonFrame skeletonFrame = e.OpenSkeletonFrame()) { if (skeletonFrame != null) { skeletons = new Skeleton[skeletonFrame.SkeletonArrayLength]; skeletonFrame.CopySkeletonDataTo(skeletons); } } using (DrawingContext dc = this.drawingGroup.Open()) { // Draw a transparent background to set the render size dc.DrawRectangle(Brushes.Transparent, null, new Rect(0.0, 0.0, RenderWidth, RenderHeight)); if (skeletons.Length != 0) { foreach (Skeleton skel in skeletons) { if (skel.TrackingState == SkeletonTrackingState.Tracked) { visible = true; if (comenzado && !terminado) { updateAll(skel); //this.DrawBonesAndJoints(skel, dc); SkeletonPoint[] listOfPoints = { skel.Joints[JointType.WristRight].Position, skel.Joints[JointType.WristLeft].Position }; for (int i = 0; i < 3; i++) { if (exercise.isInMovementN(listOfPoints, i)) { drawTargets(dc, Brushes.Green, i); Step = (i + 1) % 3; score++; } else if (exercise.isInErrorMovement(listOfPoints, i)) { drawTargets(dc, Brushes.Red, i); Step = (i + 1) % 3; score--; } else { drawTargets(dc, Brushes.Yellow, i); } } } } else if (skel.TrackingState == SkeletonTrackingState.PositionOnly) { visible = false; dc.DrawEllipse( this.centerPointBrush, null, this.SkeletonPointToScreen(skel.Position), BodyCenterThickness, BodyCenterThickness); } } } // prevent drawing outside of our render area this.drawingGroup.ClipGeometry = new RectangleGeometry(new Rect(-120.0, -200.0, RenderWidth, RenderHeight)); } }
/// <summary> /// Renders the contents of the image /// </summary> /// <param name="dc">An instance of <see cref="T:Windows.UI.Xaml.Media.DrawingContext"/> used to render the control.</param> protected override void OnRender (DrawingContext dc) { if (background != null) dc.DrawRectangle (background, null, new Rect (0, 0, RenderSize.Width, RenderSize.Height)); if (Source == null) return; ImageSource src = Source; var ourSize = RenderSize.Width * RenderSize.Height; foreach (var frame in _availableFrames) { src = frame; if (frame.PixelWidth * frame.PixelHeight >= ourSize) break; } dc.DrawImage (src, new Rect (new Point (0, 0), RenderSize)); }
/// <summary> /// In addition to the child, Border renders a background + border. The background is drawn inside the border. /// </summary> protected override void OnRender(DrawingContext dc) { bool useLayoutRounding = this.UseLayoutRounding; if (_useComplexRenderCodePath) { Brush brush; StreamGeometry borderGeometry = BorderGeometryCache; if (borderGeometry != null && (brush = BorderBrush) != null) { dc.DrawGeometry(brush, null, borderGeometry); } StreamGeometry backgroundGeometry = BackgroundGeometryCache; if (backgroundGeometry != null && (brush = Background) != null) { dc.DrawGeometry(brush, null, backgroundGeometry); } } else { Thickness border = BorderThickness; Brush borderBrush; CornerRadius cornerRadius = CornerRadius; double outerCornerRadius = cornerRadius.TopLeft; // Already validated that all corners have the same radius bool roundedCorners = !DoubleUtil.IsZero(outerCornerRadius); // If we have a brush with which to draw the border, do so. // NB: We double draw corners right now. Corner handling is tricky (bevelling, &c...) and // we need a firm spec before doing "the right thing." (greglett, ffortes) if (!border.IsZero && (borderBrush = BorderBrush) != null) { // Initialize the first pen. Note that each pen is created via new() // and frozen if possible. Doing this avoids the pen // being copied when used in the DrawLine methods. Pen pen = LeftPenCache; if (pen == null) { pen = new Pen(); pen.Brush = borderBrush; if (useLayoutRounding) { pen.Thickness = UIElement.RoundLayoutValue(border.Left, FrameworkElement.DpiScaleX); } else { pen.Thickness = border.Left; } if (borderBrush.IsFrozen) { pen.Freeze(); } LeftPenCache = pen; } double halfThickness; if (border.IsUniform) { halfThickness = pen.Thickness * 0.5; // Create rect w/ border thickness, and round if applying layout rounding. Rect rect = new Rect(new Point(halfThickness, halfThickness), new Point(RenderSize.Width - halfThickness, RenderSize.Height - halfThickness)); if (roundedCorners) { dc.DrawRoundedRectangle( null, pen, rect, outerCornerRadius, outerCornerRadius); } else { dc.DrawRectangle( null, pen, rect); } } else { // Nonuniform border; stroke each edge. if (DoubleUtil.GreaterThan(border.Left, 0)) { halfThickness = pen.Thickness * 0.5; dc.DrawLine( pen, new Point(halfThickness, 0), new Point(halfThickness, RenderSize.Height)); } if (DoubleUtil.GreaterThan(border.Right, 0)) { pen = RightPenCache; if (pen == null) { pen = new Pen(); pen.Brush = borderBrush; if (useLayoutRounding) { pen.Thickness = UIElement.RoundLayoutValue(border.Right, FrameworkElement.DpiScaleX); } else { pen.Thickness = border.Right; } if (borderBrush.IsFrozen) { pen.Freeze(); } RightPenCache = pen; } halfThickness = pen.Thickness * 0.5; dc.DrawLine( pen, new Point(RenderSize.Width - halfThickness, 0), new Point(RenderSize.Width - halfThickness, RenderSize.Height)); } if (DoubleUtil.GreaterThan(border.Top, 0)) { pen = TopPenCache; if (pen == null) { pen = new Pen(); pen.Brush = borderBrush; if (useLayoutRounding) { pen.Thickness = UIElement.RoundLayoutValue(border.Top, FrameworkElement.DpiScaleY); } else { pen.Thickness = border.Top; } if (borderBrush.IsFrozen) { pen.Freeze(); } TopPenCache = pen; } halfThickness = pen.Thickness * 0.5; dc.DrawLine( pen, new Point(0, halfThickness), new Point(RenderSize.Width, halfThickness)); } if (DoubleUtil.GreaterThan(border.Bottom, 0)) { pen = BottomPenCache; if (pen == null) { pen = new Pen(); pen.Brush = borderBrush; if (useLayoutRounding) { pen.Thickness = UIElement.RoundLayoutValue(border.Bottom, FrameworkElement.DpiScaleY); } else { pen.Thickness = border.Bottom; } if (borderBrush.IsFrozen) { pen.Freeze(); } BottomPenCache = pen; } halfThickness = pen.Thickness * 0.5; dc.DrawLine( pen, new Point(0, RenderSize.Height - halfThickness), new Point(RenderSize.Width, RenderSize.Height - halfThickness)); } } } // Draw background in rectangle inside border. Brush background = Background; if (background != null) { // Intialize background Point ptTL, ptBR; if (useLayoutRounding) { ptTL = new Point(UIElement.RoundLayoutValue(border.Left, FrameworkElement.DpiScaleX), UIElement.RoundLayoutValue(border.Top, FrameworkElement.DpiScaleY)); ptBR = new Point(UIElement.RoundLayoutValue(RenderSize.Width - border.Right, FrameworkElement.DpiScaleX), UIElement.RoundLayoutValue(RenderSize.Height - border.Bottom, FrameworkElement.DpiScaleY)); } else { ptTL = new Point(border.Left, border.Top); ptBR = new Point(RenderSize.Width - border.Right, RenderSize.Height - border.Bottom); } // Do not draw background if the borders are so large that they overlap. if (ptBR.X > ptTL.X && ptBR.Y > ptTL.Y) { if (roundedCorners) { Radii innerRadii = new Radii(cornerRadius, border, false); // Determine the inner edge radius double innerCornerRadius = innerRadii.TopLeft; // Already validated that all corners have the same radius dc.DrawRoundedRectangle(background, null, new Rect(ptTL, ptBR), innerCornerRadius, innerCornerRadius); } else { dc.DrawRectangle(background, null, new Rect(ptTL, ptBR)); } } } } }
// Displays the image and calls Detect Faces. private async void BrowseButton_Click(object sender, RoutedEventArgs e) { // Get the image file to scan from the user. var openDlg = new Microsoft.Win32.OpenFileDialog(); openDlg.Filter = "JPEG Image(*.jpg)|*.jpg"; bool?result = openDlg.ShowDialog(this); // Return if canceled. if (!(bool)result) { return; } // Display the image file. string filePath = openDlg.FileName; Uri fileUri = new Uri(filePath); BitmapImage bitmapSource = new BitmapImage(); bitmapSource.BeginInit(); bitmapSource.CacheOption = BitmapCacheOption.None; bitmapSource.UriSource = fileUri; bitmapSource.EndInit(); FacePhoto.Source = bitmapSource; // Detect any faces in the image. Title = "Detecting..."; faces = await UploadAndDetectFaces(filePath); Title = String.Format("Detection Finished. {0} face(s) detected", faces.Length); if (faces.Length > 0) { // Prepare to draw rectangles around the faces. DrawingVisual visual = new DrawingVisual(); DrawingContext drawingContext = visual.RenderOpen(); drawingContext.DrawImage(bitmapSource, new Rect(0, 0, bitmapSource.Width, bitmapSource.Height)); double dpi = bitmapSource.DpiX; resizeFactor = 96 / dpi; faceDescriptions = new String[faces.Length]; for (int i = 0; i < faces.Length; ++i) { Face face = faces[i]; // Draw a rectangle on the face. drawingContext.DrawRectangle( Brushes.Transparent, new Pen(Brushes.Red, 2), new Rect( face.FaceRectangle.Left * resizeFactor, face.FaceRectangle.Top * resizeFactor, face.FaceRectangle.Width * resizeFactor, face.FaceRectangle.Height * resizeFactor ) ); // Store the face description. faceDescriptions[i] = FaceDescription(face); } drawingContext.Close(); // Display the image with the rectangle around the face. RenderTargetBitmap faceWithRectBitmap = new RenderTargetBitmap( (int)(bitmapSource.PixelWidth * resizeFactor), (int)(bitmapSource.PixelHeight * resizeFactor), 96, 96, PixelFormats.Pbgra32); faceWithRectBitmap.Render(visual); FacePhoto.Source = faceWithRectBitmap; // Set the status bar text. faceDescriptionStatusBar.Text = "Place the mouse pointer over a face to see the face description."; } }
void DrawScene(DrawingContext dc) { dc.DrawRectangle(Brushes.White, null, new Rect(0, 0, 500, 500)); DrawBall(dc); }
protected override void OnRender(DrawingContext dc) { /*var text_lines = new List<string>(); int maxlength = 0; string indent_string = new string(' ', _textView.FormattedLineSource.TabSize); var lines = _textView.TextBuffer.CurrentSnapshot.Lines; foreach (var line in lines) { string text = line.GetText(); text = text.Replace("\t", indent_string); text_lines.Add(text); maxlength = Math.Max(maxlength, text.Length); } double symbol_size = this.Width/maxlength; int line_index = 0; foreach (var line in text_lines) { int symbol_index = 0; foreach (var c in line) { if (c != ' ') { double left = symbol_index * symbol_size; var brush = new SolidColorBrush(Color.FromArgb(127, 0, 0, 0)); dc.DrawRectangle(brush, null, new Rect(left, line_index * 1.6 + 1, symbol_size, 1)) } symbol_index++; } line_index++; }*/ var snapshot = _textView.TextSnapshot; var segments = _textParser.Parse(_textView); // calculate max string length int maxlength = 0; foreach (var line in snapshot.Lines) { string text = line.GetText(); maxlength = Math.Max(maxlength, text.Length); } double symbol_size = this.Width / maxlength; foreach (var segment in segments) { string text = snapshot.GetText(segment.span); ITextSnapshotLine line = snapshot.GetLineFromPosition(segment.span.Start); double x = (segment.span.Start - line.Start.Position) * symbol_size; double y = line.LineNumber * 2.0; double w = (segment.span.Length) * symbol_size; double h = 1; var brush = new SolidColorBrush(segment.color); dc.DrawRectangle(brush, null, new Rect(x, y, w, h)); } }