         
         precondition(bitmaps.allSatisfy({ $0.channels.allSatisfy { 0...numberOfComponents ~= $0.index } }), "Invalid channel index.")
         
-        switch self {
-        case let colorSpace as ColorSpace<GrayColorModel>:
-            
-            if bitmaps.allSatisfy({ $0.bitsPerPixel == $0.channels.count * 8 && $0.isCompact && $0.channels.allSatisfy { $0.format == .unsigned } }) {
-                
-                var image = Image<Gray16ColorPixel>(width: width, height: height, resolution: resolution, colorSpace: colorSpace, fileBacked: fileBacked)
+        if bitmaps.allSatisfy({ $0.bitsPerPixel & 7 == 0 && $0.channels.allSatisfy { $0.bitRange.lowerBound & 7 == 0 } }) {
+            
+            switch self {
+            case let colorSpace as ColorSpace<GrayColorModel>:
+                
+                if bitmaps.allSatisfy({ $0.channels.allSatisfy { $0.bitRange.count == 8 && $0.format == .unsigned } }) {
+                    
+                    var image = Image<Gray16ColorPixel>(width: width, height: height, resolution: resolution, colorSpace: colorSpace, fileBacked: fileBacked)
+                    
+                    for bitmap in bitmaps {
+                        image._read_aligned_pixels(bitmap, is_opaque, UInt8.self)
+                    }
+                    
+                    if premultiplied {
+                        image._decode_premultiplied()
+                    }
+                    
+                    return image
+                    
+                } else if bitmaps.allSatisfy({ $0.channels.allSatisfy { $0.bitRange.count == 16 && $0.format == .unsigned } }) {
+                    
+                    var image = Image<Gray32ColorPixel>(width: width, height: height, resolution: resolution, colorSpace: colorSpace, fileBacked: fileBacked)
+                    
+                    for bitmap in bitmaps {
+                        image._read_aligned_pixels(bitmap, is_opaque, UInt16.self)
+                    }
+                    
+                    if premultiplied {
+                        image._decode_premultiplied()
+                    }
+                    
+                    return image
+                    
+                }
+                
+            case let colorSpace as ColorSpace<RGBColorModel>:
+                
+                if bitmaps.allSatisfy({ $0.channels.allSatisfy { $0.bitRange.count == 8 && $0.format == .unsigned } }) {
+                    
+                    var image = Image<RGBA32ColorPixel>(width: width, height: height, resolution: resolution, colorSpace: colorSpace, fileBacked: fileBacked)
+                    
+                    for bitmap in bitmaps {
+                        image._read_aligned_pixels(bitmap, is_opaque, UInt8.self)
+                    }
+                    
+                    if premultiplied {
+                        image._decode_premultiplied()
+                    }
+                    
+                    return image
+                    
+                } else if bitmaps.allSatisfy({ $0.channels.allSatisfy { $0.bitRange.count == 16 && $0.format == .unsigned } }) {
+                    
+                    var image = Image<RGBA64ColorPixel>(width: width, height: height, resolution: resolution, colorSpace: colorSpace, fileBacked: fileBacked)
+                    
+                    for bitmap in bitmaps {
+                        image._read_aligned_pixels(bitmap, is_opaque, UInt16.self)
+                    }
+                    
+                    if premultiplied {
+                        image._decode_premultiplied()
+                    }
+                    
+                    return image
+                    
+                }
+                
+            default: break
+            }
+            
+            if bitmaps.allSatisfy({ $0.channels.allSatisfy { $0.bitRange.count == 8 || $0.bitRange.count == 16 || ($0.bitRange.count == 32 && $0.format == .float) } }) {
+                
+                var image = Image<FloatColorPixel<Model>>(width: width, height: height, resolution: resolution, colorSpace: self, fileBacked: fileBacked)
                 
                 for bitmap in bitmaps {
-                    image._read_compact_pixels(bitmap, is_opaque, UInt8.self)
+                    for (channel_idx, channel) in bitmap.channels.enumerated() {
+                        switch (channel.bitRange.count, channel.format) {
+                        case (8, .unsigned): image._read_aligned_pixels(bitmap, channel_idx, is_opaque, UInt8.self, Float.self)
+                        case (8, .signed): image._read_aligned_pixels(bitmap, channel_idx, is_opaque, Int8.self, Float.self)
+                        case (16, .unsigned): image._read_aligned_pixels(bitmap, channel_idx, is_opaque, UInt16.self, Float.self)
+                        case (16, .signed): image._read_aligned_pixels(bitmap, channel_idx, is_opaque, Int16.self, Float.self)
+                        case (32, .float): image._read_aligned_pixels(bitmap, channel_idx, is_opaque, Float.self, Float.self)
+                        default: break
+                        }
+                    }
                 }
                 
                 if premultiplied {

                
                return image
                
            } else if bitmaps.allSatisfy({ $0.bitsPerPixel == $0.channels.count * 16 && $0.isCompact && $0.channels.allSatisfy { $0.format == .unsigned } }) {
                
                var image = Image<Gray32ColorPixel>(width: width, height: height, resolution: resolution, colorSpace: colorSpace, fileBacked: fileBacked)
                
                for bitmap in bitmaps {
                    image._read_compact_pixels(bitmap, is_opaque, UInt16.self)
                }
                
                if premultiplied {

        
        self.withUnsafeMutableBytes {
            
            guard var dest = $0.baseAddress?.bindMemory(to: R.self, capacity: Pixel.numberOfComponents * $0.count) else { return }
            
            let row = Pixel.numberOfComponents * width
            
            dest += bitmap.startsRow * row
            
            var data = bitmap.data
            
            for _ in bitmap.startsRow..<height {
                
                let _length = min(bitmap.bytesPerRow, data.count)
                guard _length != 0 else { return }
                
                data.popFirst(bitmap.bytesPerRow).withUnsafeBytes { (bytes: UnsafePointer<UInt8>) in
                    
                    var destination = dest
                    var source = UnsafeRawPointer(bytes)
                    let source_end = source + _length
                    
                    for _ in 0..<width {
                        
                        guard source + bytesPerPixel <= source_end else { return }
                        
                        let _destination = destination + channel.index
                        let _source = source + byteOffset
                        
                        switch channel.endianness {
                        case .big: _destination.pointee = _denormalized(R(T(bitPattern: T.BitPattern(bigEndian: _source.bindMemory(to: T.BitPattern.self, capacity: 1).pointee))))
                        case .little: _destination.pointee = _denormalized(R(T(bitPattern: T.BitPattern(littleEndian: _source.bindMemory(to: T.BitPattern.self, capacity: 1).pointee))))
                        }
                        
                        source += bytesPerPixel
                        
                        if is_opaque {
                            destination[Pixel.numberOfComponents - 1] = 1
                        }
                        
                        destination += Pixel.numberOfComponents
                    }
                    
                    dest += row
                }
            }
        }
