So wählen oder markieren Sie den Text auf Mausbewegungsereignis in WritableBitmap in wpf C#

Question

Ich habe WritableBitmap Bild und ich habe in Image Control Src festgelegt. Ich erstelle ein Rechteck, wenn der Benutzer den ausgewählten Textbereich bewegt. Ich verwende auch PDFtron SDK, um ausgewählten Text aus dem PDF-Dokument zu erhalten. wir bekommen WritableBitmap Bild von PDF. Wir müssen Text online auswählen.

ich diesen Code bin mit dem Bildschirm zu zeichnen:

System.Drawing.Rectangle rectangle = new System.Drawing.Rectangle((int)Math.Min(_downX, x), 
          (int)Math.Min(_downY, y), 
          (int)Math.Abs(_downX - x), 
          (int)Math.Abs(_downY - y)); 

System.Drawing.Bitmap myBitmap = new System.Drawing.Bitmap(@"D:\PDF\ScreenDraw\WpfApplication1\WpfApplication1\Image\Capture.PNG"); 

using (System.Drawing.Graphics g = System.Drawing.Graphics.FromImage(myBitmap)) 
{ 
    System.Drawing.Color customColor = System.Drawing.Color.FromArgb(50, System.Drawing.Color.Red); 
    System.Drawing.SolidBrush shadowBrush = new System.Drawing.SolidBrush(customColor); 
    g.FillRectangles(shadowBrush, new System.Drawing.Rectangle[] { rectangle }); 
} 

//myBitmap.Save(@"D:\PDF\abc.png"); 
//bitmapSource = new BitmapImage(new Uri(@"D:\PDF\abc.png", UriKind.Absolute)); 

using (var memory = new System.IO.MemoryStream()) 
{ 
    myBitmap.Save(memory, System.Drawing.Imaging.ImageFormat.Png); 
    memory.Position = 0; 

    var bitmapImage = new BitmapImage(); 
    bitmapImage.BeginInit(); 
    bitmapImage.StreamSource = memory; 
    bitmapImage.CacheOption = BitmapCacheOption.OnLoad; 
    bitmapImage.EndInit(); 
    Img.Source = bitmapImage; 
} 

Wie kann ich den Text mit Zeilen wiesen keine Rect weise wählen?

Ich muss Text wie in der obigen Abbildung auswählen.

Answer 1

Was Sie wollen, ist unmöglich. Sie haben eine Bitmap und es ist nicht magisch den Text darin und nichts wird das ändern. Obwohl es nichts gibt, was man dagegen tun kann. Ich habe keine Zeit für eine vollständige Lösung, aber ich kann Schritt für Schritt erklären, wie ich die bestmögliche Lösung erreichen kann.

Was können Sie tun, ist:

1. Text Dimensionen Definition - Kontrolle erstellen mit Raster auf dem Bild mit editierbaren X- und Y-Achsen-Schritt und versetzt überlagert. Dann können Sie das Gitter mit den Textzeilen (Y) kalibrieren. Und Zeichenbreite (X). So etwas sollte tun (ich glaube, Sie werden die allgemeine Idee):

   public int XGridStep 
   { 
       get { return (int)base.GetValue(XGridStepProperty); } 
       set 
       { 
        base.SetValue(XGridStepProperty, value); 
        RepaintGrid(); 
       } 
   } 
   
   public static readonly DependencyProperty XGridStepProperty = DependencyProperty.Register("XGridStepProperty", typeof(int), typeof(PlanLayout), new PropertyMetadata(100)); 
   
   public int XGridOffset 
   { 
       get { return (int)base.GetValue(XGridOffsetProperty); } 
       set 
       { 
        base.SetValue(XGridOffsetProperty, value); 
        RepaintGrid(); 
       } 
   } 
   
   public static readonly DependencyProperty XGridOffsetProperty = DependencyProperty.Register("XGridOffsetProperty", typeof(int), typeof(PlanLayout), new PropertyMetadata(0)); 
   
   public bool XGridVisible 
   { 
       get { return (bool)base.GetValue(XGridVisibleProperty); } 
       set 
       { 
        base.SetValue(XGridVisibleProperty, value); 
        RepaintGrid(); 
       } 
   } 
   
   public static readonly DependencyProperty XGridVisibleProperty = DependencyProperty.Register("XGridVisibleProperty", typeof(bool), typeof(PlanLayout), new PropertyMetadata(false)); 
   
   public int YGridStep 
   { 
       get { return (int)base.GetValue(YGridStepProperty); } 
       set 
       { 
        base.SetValue(YGridStepProperty, value); 
        RepaintGrid(); 
       } 
   } 
   
   public static readonly DependencyProperty YGridStepProperty = DependencyProperty.Register("YGridStepProperty", typeof(int), typeof(PlanLayout), new PropertyMetadata(100)); 
   
   public int YGridOffset 
   { 
       get { return (int)base.GetValue(YGridOffsetProperty); } 
       set 
       { 
        base.SetValue(YGridOffsetProperty, value); 
        RepaintGrid(); 
       } 
   } 
   
   public static readonly DependencyProperty YGridOffsetProperty = DependencyProperty.Register("YGridOffsetProperty", typeof(int), typeof(PlanLayout), new PropertyMetadata(0)); 
   
   public bool YGridVisible 
   { 
       get { return (bool)base.GetValue(YGridVisibleProperty); } 
       set 
       { 
        base.SetValue(YGridVisibleProperty, value); 
        RepaintGrid(); 
       } 
   } 
   
   public static readonly DependencyProperty YGridVisibleProperty = DependencyProperty.Register("YGridVisibleProperty", typeof(bool), typeof(PlanLayout), new PropertyMetadata(false)); 
   
   private void RepaintGrid() 
   { 
       if (!IsEditable) 
        return; 
   
       foreach (Line l in _gridXLines) 
        content.Children.Remove(l); 
       _gridXLines.Clear(); 
       if (XGridVisible) 
        for (int i = XGridOffset; i < content.ActualWidth; i += XGridStep) 
        { 
         Line line = new Line(); 
         line.IsHitTestVisible = false; 
         line.Stroke = Brushes.Black; 
         line.Y1 = 0; 
         line.Y2 = content.ActualHeight; 
         line.X1 = line.X2 = i; 
         if (Math.Abs(line.X1 - content.ActualWidth) < XGridStep * 0.5 || line.X1 < XGridStep * 0.5) 
          continue; 
         _gridXLines.Add(line); 
         content.Children.Add(line); 
         Canvas.SetZIndex(line, 0); 
        } 
   
       foreach (Line l in _gridYLines) 
        content.Children.Remove(l); 
       _gridYLines.Clear(); 
       if (YGridVisible) 
        for (int i = YGridOffset; i < content.ActualHeight; i += YGridStep) 
        { 
         Line line = new Line(); 
         line.IsHitTestVisible = false; 
         line.Stroke = Brushes.Black; 
         line.X1 = 0; 
         line.X2 = content.ActualWidth; 
         line.Y1 = line.Y2 = i; 
         if (Math.Abs(line.Y1 - content.ActualHeight) < YGridStep * 0.5 || line.Y1 < YGridStep * 0.5) 
          continue; 
         _gridYLines.Add(line); 
         content.Children.Add(line); 
         Canvas.SetZIndex(line, 0); 
        } 
   } 
   

2. Textauswahl - Alles, was Sie jetzt tun müssen, ist hinzuzufügen „Am Raster ausrichten“ Fähigkeit zu Ihrer Kontrolle. Wiederum nur als Referenz:

   private void elementWrapper_MouseMove(object sender, System.Windows.Input.MouseEventArgs e) 
   { 
       if (_mouseHandlingMode != MouseHandlingMode.Dragging) 
        return; 
   
       SelectableElement element = (SelectableElement)sender; 
   
       Point curContentPoint = e.GetPosition(content); 
       //Vector elementDragVector = curContentPoint - _origContentMouseDownPoint; 
   
       _origContentMouseDownPoint = curContentPoint; 
   
       //double destinationLeft = Canvas.GetLeft(element) + elementDragVector.X; 
       //double destinationTop = Canvas.GetTop(element) + elementDragVector.Y; 
       double destinationLeft = curContentPoint.X - element.ActualWidth/2; 
       double destinationTop = curContentPoint.Y - element.ActualHeight/2; 
   
       if (SnapToGrid) 
       { 
        if (XGridVisible) 
        { 
         foreach (Line l in _gridXLines) 
          l.StrokeThickness = 1; 
   
         Line nearest = GetNearestXGridLine((int)curContentPoint.X); 
   
         if (Math.Abs(curContentPoint.X - nearest.X1) < XGridStep * 0.2) 
         { 
          destinationLeft = nearest.X1 - element.ActualWidth/2; 
          nearest.StrokeThickness = 3; 
         } 
        } 
   
        if (YGridVisible) 
        { 
         foreach (Line l in _gridYLines) 
          l.StrokeThickness = 1; 
   
         Line nearest = GetNearestYGridLine((int)curContentPoint.Y); 
   
         if (Math.Abs(curContentPoint.Y - nearest.Y1) < YGridStep * 0.2) 
         { 
          destinationTop = nearest.Y1 - element.ActualHeight/2; 
          nearest.StrokeThickness = 3; 
         } 
        } 
       } 
   
       if (destinationLeft < 0) 
        destinationLeft = 0; 
   
       if (destinationLeft > content.ActualWidth - element.ActualWidth) 
        destinationLeft = content.ActualWidth - element.ActualWidth; 
   
       if (destinationTop < 0) 
        destinationTop = 0; 
   
       if (destinationTop > content.ActualHeight - element.ActualHeight) 
        destinationTop = content.ActualHeight - element.ActualHeight; 
   
       Canvas.SetLeft(element, destinationLeft); 
       Canvas.SetTop(element, destinationTop); 
   
       element.ElementContent.Position.X = curContentPoint.X; 
       element.ElementContent.Position.Y = curContentPoint.Y; 
   
       e.Handled = true; 
   } 
   
   private Line GetNearestXGridLine(int xpos) 
   { 
       return _gridXLines.OrderBy(gl => Math.Abs((int)gl.X1 - xpos)).First(); 
   } 
   
   private Line GetNearestYGridLine(int Ypos) 
   { 
       return _gridYLines.OrderBy(gl => Math.Abs((int)gl.Y1 - Ypos)).First(); 
   } 
   

3. Graphische Darstellung der Auswahl - Now 3 Rechtecke ziehen (bis zu): von der oberen linken Punkt des Auswahlpunkt des jeweiligen Textzeile, topleft Punkt des zu Bottom nächste Zeile zum unteren rechten Punkt der Zeile vor dem letzten ausgewählten und letzten freien Punkt der letzten Zeile nach rechts unten der Auswahl

4. Get text - Get partielle Textdaten aus diesen Rechtecken und Join.