Add sd_colorsWithRect method and test, treat RGB color with default alpha 1.0

SDWebImage/UIImage+Transform.h

@@ -31,7 +31,7 @@ typedef NS_OPTIONS(NSUInteger, SDRectCorner) {
 @interface UIColor (Additions)
 
 /**
- Convenience way to get hex string from color. The output should always be 32-bit hex string like `#00000000`.
+ Convenience way to get hex string from color. The output should always be 32-bit RGBA hex string like `#00000000`.
  */
 @property (nonatomic, copy, readonly, nonnull) NSString *sd_hexString;
 
@@ -116,22 +116,33 @@ typedef NS_OPTIONS(NSUInteger, SDRectCorner) {
 #pragma mark - Image Blending
 
 /**
- Return a tinted image in alpha channel with the given color.
+ Return a tinted image with the given color. This actually use alpha blending of current image and the tint color.
  
- @param tintColor  The color.
+ @param tintColor  The tint color.
  @return The new image with the tint color.
  */
 - (nullable UIImage *)sd_tintedImageWithColor:(nonnull UIColor *)tintColor;
 
 /**
- Return the color at specify pixel. The point is from the top-left to the bottom-right and 0-based. The returned the color is always be RGBA format.
+ Return the pixel color at specify position. The point is from the top-left to the bottom-right and 0-based. The returned the color is always be RGBA format. The image must be CG-based.
  @note The point's x/y should not be smaller than 0, or greater than or equal to width/height.
+ @note The overhead of object creation means this method is best suited for infrequent color sampling. For heavy image processing, grab the raw bitmap data and process yourself.
 
  @param point The position of pixel
  @return The color for specify pixel, or nil if any error occur
  */
 - (nullable UIColor *)sd_colorAtPoint:(CGPoint)point;
 
+/**
+ Return the pixel color array with specify rectangle. The rect is from the top-left to the bottom-right and 0-based. The returned the color is always be RGBA format. The image must be CG-based.
+ @note The rect's width/height should not be smaller than or equal to 0. The minX/minY should not be smaller than 0. The maxX/maxY should not be greater than width/height. Attention this limit is different from point(point: (0,0) like rect: (0, 0, 1, 1))
+ @note The overhead of object creation means this method is best suited for infrequent color sampling. For heavy image processing, grab the raw bitmap data and process yourself.
+
+ @param rect The rectangle of pixels
+ @return The color array for specify pixels, or nil if any error occur
+ */
+- (nullable NSArray<UIColor *> *)sd_colorsWithRect:(CGRect)rect;
+
 #pragma mark - Image Effect
 
 /**

SDWebImage/UIImage+Transform.m

@@ -81,7 +81,7 @@ static UIImage * SDGraphicsGetImageFromCurrentImageContext(void) {
 #endif
 }
 
-static CGRect SDCGRectFitWithScaleMode(CGRect rect, CGSize size, SDImageScaleMode scaleMode) {
+static inline CGRect SDCGRectFitWithScaleMode(CGRect rect, CGSize size, SDImageScaleMode scaleMode) {
     rect = CGRectStandardize(rect);
     size.width = size.width < 0 ? -size.width : size.width;
     size.height = size.height < 0 ? -size.height : size.height;
@@ -122,6 +122,109 @@ static CGRect SDCGRectFitWithScaleMode(CGRect rect, CGSize size, SDImageScaleMod
     return rect;
 }
 
+static inline UIColor * SDGetColorFromPixel(Pixel_8888 pixel, CGBitmapInfo bitmapInfo) {
+    // Get alpha info, byteOrder info
+    CGImageAlphaInfo alphaInfo = bitmapInfo & kCGBitmapAlphaInfoMask;
+    CGImageByteOrderInfo byteOrderInfo = bitmapInfo & kCGBitmapByteOrderMask;
+    CGFloat r = 0, g = 0, b = 0, a = 255.0;
+    
+    BOOL byteOrderNormal = NO;
+    switch (byteOrderInfo) {
+        case kCGBitmapByteOrderDefault: {
+            byteOrderNormal = YES;
+        } break;
+        case kCGBitmapByteOrder32Little: {
+        } break;
+        case kCGBitmapByteOrder32Big: {
+            byteOrderNormal = YES;
+        } break;
+        default: break;
+    }
+    switch (alphaInfo) {
+        case kCGImageAlphaPremultipliedFirst:
+        case kCGImageAlphaFirst: {
+            if (byteOrderNormal) {
+                // ARGB8888
+                a = pixel[0] / 255.0;
+                r = pixel[1] / 255.0;
+                g = pixel[2] / 255.0;
+                b = pixel[3] / 255.0;
+            } else {
+                // BGRA8888
+                b = pixel[0] / 255.0;
+                g = pixel[1] / 255.0;
+                r = pixel[2] / 255.0;
+                a = pixel[3] / 255.0;
+            }
+        }
+            break;
+        case kCGImageAlphaPremultipliedLast:
+        case kCGImageAlphaLast: {
+            if (byteOrderNormal) {
+                // RGBA8888
+                r = pixel[0] / 255.0;
+                g = pixel[1] / 255.0;
+                b = pixel[2] / 255.0;
+                a = pixel[3] / 255.0;
+            } else {
+                // ABGR8888
+                a = pixel[0] / 255.0;
+                b = pixel[1] / 255.0;
+                g = pixel[2] / 255.0;
+                r = pixel[3] / 255.0;
+            }
+        }
+            break;
+        case kCGImageAlphaNone: {
+            if (byteOrderNormal) {
+                // RGB
+                r = pixel[0] / 255.0;
+                g = pixel[1] / 255.0;
+                b = pixel[2] / 255.0;
+            } else {
+                // BGR
+                b = pixel[0] / 255.0;
+                g = pixel[1] / 255.0;
+                r = pixel[2] / 255.0;
+            }
+        }
+            break;
+        case kCGImageAlphaNoneSkipLast: {
+            if (byteOrderNormal) {
+                // RGBX
+                r = pixel[0] / 255.0;
+                g = pixel[1] / 255.0;
+                b = pixel[2] / 255.0;
+            } else {
+                // XBGR
+                b = pixel[1] / 255.0;
+                g = pixel[2] / 255.0;
+                r = pixel[3] / 255.0;
+            }
+        }
+            break;
+        case kCGImageAlphaNoneSkipFirst: {
+            if (byteOrderNormal) {
+                // XRGB
+                r = pixel[1] / 255.0;
+                g = pixel[2] / 255.0;
+                b = pixel[3] / 255.0;
+            } else {
+                // BGRX
+                b = pixel[0] / 255.0;
+                g = pixel[1] / 255.0;
+                r = pixel[2] / 255.0;
+            }
+        }
+            break;
+        case kCGImageAlphaOnly:
+        default:
+            break;
+    }
+    
+    return [UIColor colorWithRed:r green:g blue:b alpha:a];
+}
+
 @implementation UIColor (Additions)
 
 - (NSString *)sd_hexString {
@@ -419,115 +522,79 @@ static CGRect SDCGRectFitWithScaleMode(CGRect rect, CGSize size, SDImageScaleMod
         CFRelease(data);
         return nil;
     }
-    UInt8 pixel[4] = {0};
+    Pixel_8888 pixel = {0};
     CFDataGetBytes(data, range, pixel);
     CFRelease(data);
     
     // Convert to color
-    CGImageAlphaInfo alphaInfo = CGImageGetAlphaInfo(imageRef);
     CGBitmapInfo bitmapInfo = CGImageGetBitmapInfo(imageRef);
-    CGFloat r = 0, g = 0, b = 0, a = 0;
+    return SDGetColorFromPixel(pixel, bitmapInfo);
+}
+
+- (NSArray<UIColor *> *)sd_colorsWithRect:(CGRect)rect {
+    if (!self) {
+        return nil;
+    }
+    CGImageRef imageRef = self.CGImage;
+    if (!imageRef) {
+        return nil;
+    }
     
-    BOOL byteOrderNormal = NO;
-    switch (bitmapInfo & kCGBitmapByteOrderMask) {
-        case kCGBitmapByteOrderDefault: {
-            byteOrderNormal = YES;
-        } break;
-        case kCGBitmapByteOrder32Little: {
-        } break;
-        case kCGBitmapByteOrder32Big: {
-            byteOrderNormal = YES;
-        } break;
-        default: break;
+    // Check rect
+    CGFloat width = CGImageGetWidth(imageRef);
+    CGFloat height = CGImageGetHeight(imageRef);
+    if (CGRectGetWidth(rect) <= 0 || CGRectGetHeight(rect) <= 0 || CGRectGetMinX(rect) < 0 || CGRectGetMinY(rect) < 0 || CGRectGetMaxX(rect) > width || CGRectGetMaxY(rect) > height) {
+        return nil;
     }
-    switch (alphaInfo) {
-        case kCGImageAlphaPremultipliedFirst:
-        case kCGImageAlphaFirst: {
-            if (byteOrderNormal) {
-                // ARGB8888
-                a = pixel[0] / 255.0;
-                r = pixel[1] / 255.0;
-                g = pixel[2] / 255.0;
-                b = pixel[3] / 255.0;
-            } else {
-                // BGRA8888
-                b = pixel[0] / 255.0;
-                g = pixel[1] / 255.0;
-                r = pixel[2] / 255.0;
-                a = pixel[3] / 255.0;
-            }
-        }
-            break;
-        case kCGImageAlphaPremultipliedLast:
-        case kCGImageAlphaLast: {
-            if (byteOrderNormal) {
-                // RGBA8888
-                r = pixel[0] / 255.0;
-                g = pixel[1] / 255.0;
-                b = pixel[2] / 255.0;
-                a = pixel[3] / 255.0;
-            } else {
-                // ABGR8888
-                a = pixel[0] / 255.0;
-                b = pixel[1] / 255.0;
-                g = pixel[2] / 255.0;
-                r = pixel[3] / 255.0;
-            }
-        }
-            break;
-        case kCGImageAlphaNone: {
-            if (byteOrderNormal) {
-                // RGB
-                r = pixel[0] / 255.0;
-                g = pixel[1] / 255.0;
-                b = pixel[2] / 255.0;
-            } else {
-                // BGR
-                b = pixel[0] / 255.0;
-                g = pixel[1] / 255.0;
-                r = pixel[2] / 255.0;
-            }
-        }
-            break;
-        case kCGImageAlphaNoneSkipLast: {
-            if (byteOrderNormal) {
-                // RGBX
-                r = pixel[0] / 255.0;
-                g = pixel[1] / 255.0;
-                b = pixel[2] / 255.0;
-            } else {
-                // XBGR
-                b = pixel[1] / 255.0;
-                g = pixel[2] / 255.0;
-                r = pixel[3] / 255.0;
-            }
-        }
-            break;
-        case kCGImageAlphaNoneSkipFirst: {
-            if (byteOrderNormal) {
-                // XRGB
-                r = pixel[1] / 255.0;
-                g = pixel[2] / 255.0;
-                b = pixel[3] / 255.0;
-            } else {
-                // BGRX
-                b = pixel[0] / 255.0;
-                g = pixel[1] / 255.0;
-                r = pixel[2] / 255.0;
-            }
+    
+    // Get pixels
+    CGDataProviderRef provider = CGImageGetDataProvider(imageRef);
+    if (!provider) {
+        return nil;
+    }
+    CFDataRef data = CGDataProviderCopyData(provider);
+    if (!data) {
+        return nil;
+    }
+    
+    // Get pixels with rect
+    size_t bytesPerRow = CGImageGetBytesPerRow(imageRef);
+    size_t components = CGImageGetBitsPerPixel(imageRef) / CGImageGetBitsPerComponent(imageRef);
+    
+    size_t start = bytesPerRow * CGRectGetMinY(rect) + components * CGRectGetMinX(rect);
+    size_t end = bytesPerRow * (CGRectGetMaxY(rect) - 1) + components * CGRectGetMaxX(rect);
+    if (CFDataGetLength(data) < (CFIndex)end) {
+        CFRelease(data);
+        return nil;
+    }
+    
+    const UInt8 *pixels = CFDataGetBytePtr(data);
+    size_t row = CGRectGetMinY(rect);
+    size_t col = CGRectGetMaxX(rect);
+    
+    // Convert to color
+    CGBitmapInfo bitmapInfo = CGImageGetBitmapInfo(imageRef);
+    NSMutableArray<UIColor *> *colors = [NSMutableArray arrayWithCapacity:CGRectGetWidth(rect) * CGRectGetHeight(rect)];
+    for (size_t index = start; index < end; index += 4) {
+        if (index >= row * bytesPerRow + col * components) {
+            // Index beyond the end of current row, go next row
+            row++;
+            index = row * bytesPerRow + CGRectGetMinX(rect) * components;
+            index -= 4;
+            continue;
         }
-            break;
-        case kCGImageAlphaOnly:
-        default:
-            break;
+        Pixel_8888 pixel = {pixels[index], pixels[index+1], pixels[index+2], pixels[index+3]};
+        UIColor *color = SDGetColorFromPixel(pixel, bitmapInfo);
+        [colors addObject:color];
     }
+    CFRelease(data);
     
-    return [UIColor colorWithRed:r green:g blue:b alpha:a];
+    return [colors copy];
 }
 
 #pragma mark - Image Effect
 
-// We use vImage to do box convolve for performance. However, you can just use `CIFilter.CIBoxBlur`. For other blur effect, use any filter in `CICategoryBlur`
+// We use vImage to do box convolve for performance and support for watchOS. However, you can just use `CIFilter.CIBoxBlur`. For other blur effect, use any filter in `CICategoryBlur`
 - (UIImage *)sd_blurredImageWithRadius:(CGFloat)blurRadius {
     if (self.size.width < 1 || self.size.height < 1) {
         return nil;

Tests/Tests/SDCategoriesTests.m

@@ -119,6 +119,14 @@
     BOOL vertical = YES;
     UIImage *flippedImage = [self.testImage sd_flippedImageWithHorizontal:horizontal vertical:vertical];
     expect(CGSizeEqualToSize(flippedImage.size, self.testImage.size)).beTruthy();
+    // Test pixel colors method here
+    UIColor *checkColor = [flippedImage sd_colorAtPoint:CGPointMake(75, 75)];
+    expect(checkColor);
+    NSArray<UIColor *> *checkColors = [flippedImage sd_colorsWithRect:CGRectMake(75, 75, 10, 10)]; // Rect are all same color
+    expect(checkColors.count).to.equal(10 * 10);
+    for (UIColor *color in checkColors) {
+        expect([color isEqual:checkColor]).to.beTruthy();
+    }
 }
 
 - (void)test10UIImageTransformTint {