UIImage für nur bestimmten Bereich Grenzen gezogen Schritte - PaintView

Question

ich bereits Farbe umgesetzt haben/zeichnen mit:

- (void) touchesBegan: (NSSet *) touches withEvent: (UIEvent *) event 
-(void) touchesMoved: (NSSet *) touches withEvent: (UIEvent *) event 
- (void) touchesEnded: (NSSet *) touches withEvent: (UIEvent *) event 

Jetzt Problem ist, dass gezeichnet für jede Linie, ich möchte, dass bestimmte Linie/Farbe Bild erhalten. Ich möchte kein Bild des gesamten Bildschirms, nur Fläche/Grenzen der gezeichneten Linie/Farbe.

Grund ist, dass ich Pan Gesten/Löschen Funktionalität auf dieser Linie/Farbe gezeichnet ausführen möchte.

Benutzer kann mehrere Zeilen zeichnen, so wollen UIImage für alle diese Zeilen separat. Jede Logik oder Code

Snippet werden wirklich hilfreich

Vielen Dank im Voraus

Answer 1

Je nach Anwendung, vor allem, wie oft Sie planen, dies in einer Reihe auf tun, können Sie in der Lage sein, eine andere zu schaffen image/layer für jede Farblinie. Ihr endgültiges Bild wäre im Wesentlichen alle einzelnen Linien übereinander gezeichnet.

Es kann effizienter sein, eine benutzerdefinierte Ansicht zum Erfassen von Berührungsereignissen zu erstellen. Sie können die Liste der Berührungskoordinaten für jede Mallinie speichern und sie alle gleichzeitig in einem benutzerdefinierten DrawRect rendern. Auf diese Weise speichern Sie Listen mit Koordinaten für jede Mallinie und können immer noch auf jede anstelle einer Liste von Bildern zugreifen. Sie können den Bereich/die Grenzen aus den Koordinaten berechnen, die zum Rendern der Linie verwendet werden.

Zusätzliche Kontext und Code kann hilfreich sein, ich bin mir nicht sicher, ich verstehe vollständig, was Sie erreichen möchten!

Answer 2

Ich schaue mir das MVPaint-Projekt an. Es scheint, dass Sie ein Objekt haben:

MVPaintDrawing _drawing;

enthält ein Array von MVPaintTransaction. Sie können auf diese MVPaintTransaction iterieren, um eine UIImage zu zeichnen.

Also zunächst können Sie eine Methode hinzufügen, um ein Bild von einem MVPaintTransaction zu bekommen:

- (UIImage *) imageToDrawWithSize:(CGSize) size xScale:(CGFloat)xScale yScale:(CGFloat)yScale { 

    UIGraphicsBeginImageContext(size); 
    CGContextScaleCTM(UIGraphicsGetCurrentContext(), xScale, yScale); 

    // call the existing draw method  
    [self draw]; 

    UIImage *result = UIGraphicsGetImageFromCurrentImageContext(); 
    UIGraphicsEndImageContext(); 

    return result; 
} 

Dann fügen Sie eine Methode, um eine Anordnung von Bild von der Anordnung von MVPaintTransaction in der MVPaintDrawing Klasse:

- (NSArray *) getImagesFromDrawingOnSurface: (UIImageView *) surface xScale: (CGFloat) xScale yScale: (CGFloat) yScale{ 

    NSMutableArray *imageArray = [NSMutableArray new]; 
    for (MVPaintTransaction * transaction in _drawing) { 
     UIImage *image = [transaction imageToDrawWithSize:surface.frame.size xScale:xScale yScale:yScale]; 
     [imageArray addObject:image]; 
    } 

    return imageArray; 
} 

Auf diese Weise haben Sie ein Array von UIImage entsprechend jeder Zeile, die Sie gezeichnet haben. Wenn Sie diese Bilder die „Minimum“ mögliche Größe haben wollen (ich meine, ohne zusätzlichen Alpha-Teil), können Sie sich bewerben this method (Ich habe es in der MVPaintTransaction Klasse):

- (UIImage *)trimmedImage:(UIImage *)img { 

    CGImageRef inImage = img.CGImage; 
    CFDataRef m_DataRef; 
    m_DataRef = CGDataProviderCopyData(CGImageGetDataProvider(inImage)); 

    UInt8 * m_PixelBuf = (UInt8 *) CFDataGetBytePtr(m_DataRef); 

    size_t width = CGImageGetWidth(inImage); 
    size_t height = CGImageGetHeight(inImage); 

    CGPoint top,left,right,bottom; 

    BOOL breakOut = NO; 
    for (int x = 0;breakOut==NO && x < width; x++) { 
     for (int y = 0; y < height; y++) { 
      int loc = x + (y * width); 
      loc *= 4; 
      if (m_PixelBuf[loc + 3] != 0) { 
       left = CGPointMake(x, y); 
       breakOut = YES; 
       break; 
      } 
     } 
    } 

    breakOut = NO; 
    for (int y = 0;breakOut==NO && y < height; y++) { 

     for (int x = 0; x < width; x++) { 

      int loc = x + (y * width); 
      loc *= 4; 
      if (m_PixelBuf[loc + 3] != 0) { 
       top = CGPointMake(x, y); 
       breakOut = YES; 
       break; 
      } 

     } 
    } 

    breakOut = NO; 
    for (int y = height-1;breakOut==NO && y >= 0; y--) { 

     for (int x = width-1; x >= 0; x--) { 

      int loc = x + (y * width); 
      loc *= 4; 
      if (m_PixelBuf[loc + 3] != 0) { 
       bottom = CGPointMake(x, y); 
       breakOut = YES; 
       break; 
      } 

     } 
    } 

    breakOut = NO; 
    for (int x = width-1;breakOut==NO && x >= 0; x--) { 

     for (int y = height-1; y >= 0; y--) { 

      int loc = x + (y * width); 
      loc *= 4; 
      if (m_PixelBuf[loc + 3] != 0) { 
       right = CGPointMake(x, y); 
       breakOut = YES; 
       break; 
      } 

     } 
    } 


    CGFloat scale = img.scale; 

    CGRect cropRect = CGRectMake(left.x/scale, top.y/scale, (right.x - left.x)/scale, (bottom.y - top.y)/scale); 
    UIGraphicsBeginImageContextWithOptions(cropRect.size, 
              NO, 
              scale); 
    [img drawAtPoint:CGPointMake(-cropRect.origin.x, -cropRect.origin.y) 
      blendMode:kCGBlendModeCopy 
       alpha:1.]; 
    UIImage *croppedImage = UIGraphicsGetImageFromCurrentImageContext(); 
    UIGraphicsEndImageContext(); 
    CFRelease(m_DataRef); 
    return croppedImage; 
} 

Dann einfach in dem ersten Verfahren ersetzen :

return result; 

von

return [self trimmedImage:result];