Mat continuous check should use a more robust way

[4o3F]

Currently OpenCV isContinuous flag have issues (see opencv/opencv#12018), and should not be relied on for checking whether the Mat is continuous. The following code can reproduce the issue:

let continuous_mat = opencv::core::Mat::new_rows_cols_with_default(
    30076,
    39979,
    opencv::core::CV_8UC3,
    opencv::core::Scalar::all(0.),
)?;
tracing::info!("{}", continuous_mat.is_continuous());

but if I change the data type to CV_8UC1, it resulted in a continuous Mat.
Therefore, the match_is_continuous (code) should be switched to another method for checking.

[twistedfall]

I was not aware of this issue, thanks for bringing this up. If I read the report correctly though, isContinuous can return false even though the Mat is technically contiguous. This is unfortunate, but it doesn't hurt the safety, it just means that sometimes the crate will have to resort to slower code paths (e.g. in Mat::to_vec_2d) or some functionality will be not available (e.g. Mat::data_typed). I generally try to keep the crate code as lean as possible so if a bug/quirk exists in OpenCV itself the default approach will be to keep it as is.

If you think my understanding is incorrect or you have a good solution to this issue feel free to reopen this issue and suggest the improvement.

[4o3F]

Just another quick question. Since Mat::data_typed is the safe Rust helper, wouldn't it be better if it can be used on all technically contiguous Mat? Otherwise one have to use the unchecked version and write a custom safe wrapper around it.

[twistedfall]

It's would definitely be the preferred option! I will try to look into it, but maybe you have already an idea of how to check whether a Mat is really contiguous even if OpenCV lies about it?

[4o3F]

I wrote one according to my understanding of the memory layout, but not sure if it's correct.

pub fn is_physically_contiguous<T>(mat: &T) -> opencv::Result<bool>
where
    T: MatTraitConst,
{
    if mat.empty() {
        return Ok(true);
    }

    let dims = mat.dims();
    let elem_size = mat.elem_size()?;

    // Last dimension must be tightly packed
    let last_step = mat.step1(dims - 1)?;
    if last_step != elem_size {
        return Ok(false);
    }

    // Check stride chain: step[i] == step[i+1] * size[i+1]
    for i in (0..dims - 1).rev() {
        let step_i = mat.step1(i)?;
        let step_next = mat.step1(i + 1)?;
        let size_next = mat.mat_size()[(i + 1) as usize] as usize;

        let expected = step_next * size_next;
        if step_i != expected {
            return Ok(false);
        }
    }

    Ok(true)
}

I tested it on a imread result and a roi result, the return value is as expected.
The idea is to check if the strides are exactly what they would be for a tightly-packed array. The last dimension stride equals element size; every other stride equals next stride × next dimension length.