ios - Obteniendo UIImage solo para límites de área particulares dibujados-PaintView

objective-c iphone

Question

Ya he implementado pintura / dibujo usando:

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

Ahora el problema es que para cualquier línea dibujada, quiero obtener esa línea / imagen de pintura en particular. No quiero la imagen de la pantalla completa, solo el área / los límites de la línea / pintura dibujada.

La razón es que quiero llevar a cabo la función de eliminar / eliminar pan en esa línea / pintura dibujada.

El usuario puede dibujar varias líneas, por lo que quiere UIImage para todas estas líneas por separado.

Cualquier lógica o fragmento de código será realmente útil

Gracias por adelantado

Answer 1

Dependiendo de su aplicación, en particular cuántas veces planea hacer esto en una fila, es posible que pueda crear una imagen / capa diferente para cada línea de pintura. Su imagen final sería esencialmente todas las líneas individuales dibujadas una encima de la otra.

Puede ser más eficiente crear una vista personalizada para capturar eventos táctiles. Puede almacenar la lista de coordenadas táctiles para cada línea de pintura y renderizarlas todas a la vez en un drawRect personalizado. De esta manera está almacenando listas de coordenadas para cada línea de pintura, y aún puede acceder a cada una, en lugar de una lista de imágenes. Puede calcular el área / límites a partir de las coordenadas utilizadas para representar la línea.

El contexto y el código adicionales pueden ser útiles. ¡No estoy seguro de entender por completo lo que intentas lograr!

Answer 2

Echo un vistazo al proyecto MVPaint. Parece que tienes un objeto:

MVPaintDrawing _drawing;

que contiene una matriz de MVPaintTransaction . Puede iterar en esos MVPaintTransaction para dibujar un UIImage .

Entonces, primero puede agregar un método para obtener una imagen de MVPaintTransaction :

- (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;
}

A continuación, agregue un método para obtener una matriz de imágenes de la matriz de MVPaintTransaction en la clase MVPaintDrawing :

- (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;
}

De esta forma, tendrás una matriz de UIImage correspondiente a cada línea que hayas dibujado. Si desea que esas imágenes tengan el tamaño "mínimo" posible (es decir, sin parte alfa adicional), puede aplicar este método (lo agregué en la clase MVPaintTransaction ):

- (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;
}

Luego simplemente reemplace en el primer método:

return result;

por

return [self trimmedImage:result];