When should you use cv2.split() instead of NumPy channel indexing on an image?

## Two different operations that look the same Both of these give you "the blue channel": ``` b, g, r = cv2.split(img) # three new arrays, three allocations blue = img[:, :, 0] # a view: no allocation, shares memory ``` The difference is ownership of memory. OpenCV stores a colour image **interleaved**: the bytes in memory run B,G,R,B,G,R,... pixel after pixel. A single channel is therefore not a contiguous block — it is every third byte. `cv2.split` walks the image and de-interleaves it into three contiguous single-channel arrays, which costs a full copy of the image. NumPy's `img[:, :, 0]` instead constructs a view with a stride of three, pointing into the original buffer. It is free, but the underlying data is shared and non-contiguous. ## Consequences of sharing Because the view aliases the original: ``` img[:, :, 2] = 0 # removes red from img itself, in place b, g, r = cv2.split(img) r[:] = 0 # changes only the copy; img is untouched ``` This is a common source of confusion in both directions — people expect `split` results to write through (they do not) and are surprised when an assignment through an index mutates an image they meant to keep. If you need an independent copy of one channel without splitting all of them, `img[:, :, 0].copy()` is explicit and cheaper than a three-way split. ## Contiguity, and where OpenCV objects OpenCV's Python bindings require arrays whose innermost stride equals the element size. A plain `img[:, :, 0]` view has a stride of three bytes, and while many bindings will silently copy it for you, the reversed-channel trick `img[:, :, ::-1]` — negative stride — is routinely rejected with a layout error. `np.ascontiguousarray` resolves it, at which point you have paid the copy you were trying to avoid, and `cv2.cvtColor` or `cv2.split` would have been the clearer way to spend it. ## merge, and the order trap `cv2.merge([b, g, r])` interleaves single-channel arrays back into one multi-channel image. All inputs must share shape and dtype. The **list order is the channel order** — nothing checks that you passed blue first. `cv2.merge([r, g, b])` produces a perfectly valid image with red and blue exchanged, which then looks wrong only when displayed, exactly like the BGR/RGB bug. Naming the variables after the channels they hold, rather than `c0, c1, c2`, is what prevents this. `cv2.mixChannels` exists for arbitrary channel remappings without the intermediate list, and is the efficient choice when you need an unusual permutation, but split/merge is far more readable for the everyday cases. ## The pattern that justifies split/merge The reason split and merge earn their place is single-channel processing in a non-BGR colour space: ``` lab = cv2.cvtColor(bgr, cv2.COLOR_BGR2LAB) l, a, b = cv2.split(lab) l = cv2.createCLAHE(clipLimit=2.0, tileGridSize=(8, 8)).apply(l) out = cv2.cvtColor(cv2.merge([l, a, b]), cv2.COLOR_LAB2BGR) ``` Here the operation genuinely needs a standalone single-channel image — it is a filter that takes one channel as its input — and the result must be reassembled. Applying the same enhancement to each BGR channel separately would shift the colours, because it would change the ratios between channels; isolating a lightness-like channel changes brightness while leaving the colour axes alone. ## Performance in a loop On a per-frame video loop, split/merge is two full image copies per frame. At 1080p that is a few megabytes each, per frame, and it shows up in profiles. Prefer indexing when you only read; prefer in-place assignment when you only write one channel; reserve split/merge for the reassemble pattern above. If you find yourself splitting and immediately merging the same three arrays unchanged, delete both calls — that sequence is a no-op that costs two copies. ## Quick rules - Reading a channel to compute a statistic: index it. - Zeroing or replacing one channel of an image you own: assign into the index, in place. - Feeding one channel into a function that wants a single-channel image, then putting it back: split and merge. - Reordering channels wholesale: `cv2.cvtColor`, not manual split/merge — it is clearer and it returns contiguous data.