Add files using upload-large-folder tool

.gitattributes

@@ -1200,3 +1200,5 @@ vlmpy310/lib/python3.10/site-packages/skimage/segmentation/_quickshift_cy.cpytho
 vlmpy310/lib/python3.10/site-packages/skimage/segmentation/_slic.cpython-310-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text
 llava_next/lib/python3.10/site-packages/torch/__pycache__/_torch_docs.cpython-310.pyc filter=lfs diff=lfs merge=lfs -text
 llava_next/lib/python3.10/site-packages/torch/__pycache__/_tensor_docs.cpython-310.pyc filter=lfs diff=lfs merge=lfs -text
+vlmpy310/lib/python3.10/site-packages/skimage/filters/_multiotsu.cpython-310-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text
+valley/lib/python3.10/site-packages/nvidia/cudnn/lib/libcudnn_ops.so.9 filter=lfs diff=lfs merge=lfs -text

parrot/lib/python3.10/site-packages/deepspeed/inference/v2/kernels/ragged_ops/includes/top_k_utils.h

@@ -0,0 +1,15 @@
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0
+
+// DeepSpeed Team
+
+#define TOP_K_SWITCH(N_TOP_K, ...)         \
+    [&] {                                  \
+        if (1 == N_TOP_K) {                \
+            constexpr int CONST_TOP_K = 1; \
+            __VA_ARGS__();                 \
+        } else if (2 == N_TOP_K) {         \
+            constexpr int CONST_TOP_K = 2; \
+            __VA_ARGS__();                 \
+        }                                  \
+    }()

parrot/lib/python3.10/site-packages/deepspeed/inference/v2/kernels/ragged_ops/linear_blocked_kv_rotary/__init__.py

@@ -0,0 +1,8 @@
+# Copyright (c) Microsoft Corporation.
+# SPDX-License-Identifier: Apache-2.0
+
+# DeepSpeed Team
+
+from .blocked_kv_rotary import *
+from .blocked_trained_kv_rotary import *
+from .linear_blocked_kv_copy import *

parrot/lib/python3.10/site-packages/deepspeed/inference/v2/kernels/ragged_ops/linear_blocked_kv_rotary/blocked_kv_rotary.cpp

@@ -0,0 +1,195 @@
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0
+
+// DeepSpeed Team
+
+#include "blocked_kv_rotary.h"
+#include "ragged_kernel_helpers.h"
+
+#define DISPATCH_KV_ROTARY(T_TYPE, C_TYPE)                                 \
+    if (q.options().dtype() == torch::T_TYPE) {                            \
+        launch_kv_rotary_kernel<C_TYPE>((C_TYPE*)kv_cache.data_ptr(),      \
+                                        (C_TYPE*)q.data_ptr(),             \
+                                        (C_TYPE*)k.data_ptr(),             \
+                                        (C_TYPE*)v.data_ptr(),             \
+                                        (C_TYPE*)inv_freq_ptr,             \
+                                        rotary_dim,                        \
+                                        theta_base,                        \
+                                        batch_wrapper,                     \
+                                        qkv_stride,                        \
+                                        kv_cache_stride,                   \
+                                        v_offset,                          \
+                                        inv_freq_stride,                   \
+                                        q_ratio,                           \
+                                        head_size,                         \
+                                        n_tokens,                          \
+                                        n_q_heads,                         \
+                                        at::cuda::getCurrentCUDAStream()); \
+    }
+
+/*
+Rotary position embeddings + copy into KV cache. This implementation assumes
+that the inverse frequencies should be ready from global memory rather than
+synthesized in the kernel.
+
+Arguments:
+    kv_cache: [n_blocks, block_size, 2, n_kv_heads, head_size]
+    q: [n_tokens, n_q_heads * head_size]
+    k: [n_tokens, n_kv_heads * head_size]
+    v: [n_tokens, n_kv_heads * head_size]
+    inv_freq: [max_seq_len, head_size // 2]
+*/
+void kv_trained_rotary_embeddings(torch::Tensor& kv_cache,
+                                  torch::Tensor& q,
+                                  torch::Tensor& k,
+                                  torch::Tensor& v,
+                                  torch::Tensor& inv_freq,
+                                  torch::Tensor& batch_metadata,
+                                  torch::Tensor& seq_metadata,
+                                  torch::Tensor& tokens_to_seq,
+                                  torch::Tensor& kv_ptrs)
+{
+    const int32_t n_tokens = q.size(0);
+    TORCH_CHECK(n_tokens == k.size(0));
+    TORCH_CHECK(n_tokens == v.size(0));
+
+    const float theta_base = 0.f;
+    const int32_t rotary_dim = inv_freq.size(0) * 2;
+
+    // Dimensions
+    const int32_t block_size = kv_cache.size(1);
+    const int32_t n_kv_heads = kv_cache.size(3);
+    const int32_t head_size = kv_cache.size(4);
+
+    // Strides
+    const int32_t qkv_stride = q.stride(0);              // Per token
+    const int32_t kv_cache_stride = kv_cache.stride(1);  // Per token
+    const int32_t v_offset = kv_cache.stride(2);         // From k_cache to v_cache
+    const int32_t inv_freq_stride = inv_freq.stride(0);  // Per token idx
+
+    const int n_q_heads = q.size(1) / head_size;
+    const int q_ratio = n_q_heads / n_kv_heads;
+
+    void* inv_freq_ptr = (void*)inv_freq.data_ptr();
+
+    BatchWrapperCPP batch_wrapper = make_cpp_batch_wrapper(
+        batch_metadata, seq_metadata, tokens_to_seq, kv_ptrs, block_size, kv_cache.size(0));
+
+    DISPATCH_KV_ROTARY(kHalf, __half);
+
+#ifdef BF16_AVAILABLE
+    DISPATCH_KV_ROTARY(kBFloat16, __nv_bfloat16);
+#endif
+}
+
+/*
+Rotary position embeddings + copy into KV cache. This implementation assumes
+that the inverse frequencies should be synthesized in the kernel.
+
+Arguments:
+    kv_cache: [n_blocks, block_size, 2, n_kv_heads, head_size]
+    q: [n_tokens, n_q_heads * head_size]
+    k: [n_tokens, n_kv_heads * head_size]
+    v: [n_tokens, n_kv_heads * head_size]
+*/
+void kv_rotary_embeddings(torch::Tensor& kv_cache,
+                          torch::Tensor& q,
+                          torch::Tensor& k,
+                          torch::Tensor& v,
+                          const int32_t rotary_dim,
+                          const float theta_base,
+                          torch::Tensor& batch_metadata,
+                          torch::Tensor& seq_metadata,
+                          torch::Tensor& tokens_to_seq,
+                          torch::Tensor& kv_ptrs)
+{
+    const int32_t n_tokens = q.size(0);
+    TORCH_CHECK(n_tokens == k.size(0));
+    TORCH_CHECK(n_tokens == v.size(0));
+
+    // Dimensions
+    const int32_t block_size = kv_cache.size(1);
+    const int32_t n_kv_heads = kv_cache.size(3);
+    const int32_t head_size = kv_cache.size(4);
+
+    // Strides
+    const int32_t qkv_stride = q.stride(0);              // Per token
+    const int32_t kv_cache_stride = kv_cache.stride(1);  // Per token
+    const int32_t v_offset = kv_cache.stride(2);         // From k_cache to v_cache
+    const int32_t inv_freq_stride = 0;                   // Per token idx
+
+    const int n_q_heads = q.size(1) / head_size;
+    const int q_ratio = n_q_heads / n_kv_heads;
+
+    void* inv_freq_ptr = nullptr;
+
+    BatchWrapperCPP batch_wrapper = make_cpp_batch_wrapper(
+        batch_metadata, seq_metadata, tokens_to_seq, kv_ptrs, block_size, kv_cache.size(0));
+
+    DISPATCH_KV_ROTARY(kHalf, __half);
+
+#ifdef BF16_AVAILABLE
+    DISPATCH_KV_ROTARY(kBFloat16, __nv_bfloat16);
+#endif
+}
+
+#define DISPATCH_KV_COPY(T_TYPE, C_TYPE)                                 \
+    if (q.options().dtype() == torch::T_TYPE) {                          \
+        launch_kv_copy_kernel<C_TYPE>((C_TYPE*)kv_cache.data_ptr(),      \
+                                      (C_TYPE*)q.data_ptr(),             \
+                                      (C_TYPE*)k.data_ptr(),             \
+                                      (C_TYPE*)v.data_ptr(),             \
+                                      batch_wrapper,                     \
+                                      qkv_stride,                        \
+                                      kv_cache_stride,                   \
+                                      v_offset,                          \
+                                      q_ratio,                           \
+                                      head_size,                         \
+                                      n_tokens,                          \
+                                      n_q_heads,                         \
+                                      at::cuda::getCurrentCUDAStream()); \
+    }
+
+/*
+Copy into linear KV cache.
+*/
+void linear_kv_copy(torch::Tensor& kv_cache,
+                    torch::Tensor& q,
+                    torch::Tensor& k,
+                    torch::Tensor& v,
+                    torch::Tensor& batch_metadata,
+                    torch::Tensor& seq_metadata,
+                    torch::Tensor& tokens_to_seq,
+                    torch::Tensor& kv_ptrs)
+{
+    const int32_t n_tokens = q.size(0);
+    TORCH_CHECK(n_tokens == k.size(0));
+    TORCH_CHECK(n_tokens == v.size(0));
+
+    // Dimensions
+    const int32_t block_size = kv_cache.size(1);
+    const int32_t n_kv_heads = kv_cache.size(3);
+    const int32_t head_size = kv_cache.size(4);
+
+    // Strides
+    const int32_t qkv_stride = q.stride(0);  // Per token
+    TORCH_CHECK(qkv_stride == k.stride(0));
+    TORCH_CHECK(qkv_stride == v.stride(0));
+
+    const int32_t kv_cache_stride = kv_cache.stride(1);  // Per token
+    const int32_t v_offset = kv_cache.stride(2);         // From k_cache to v_cache
+
+    const int n_q_heads = q.size(1) / head_size;
+
+    TORCH_CHECK(n_q_heads % n_kv_heads == 0);
+    const int q_ratio = n_q_heads / n_kv_heads;
+
+    BatchWrapperCPP batch_wrapper = make_cpp_batch_wrapper(
+        batch_metadata, seq_metadata, tokens_to_seq, kv_ptrs, block_size, kv_cache.size(0));
+
+    DISPATCH_KV_COPY(kHalf, __half);
+
+#ifdef BF16_AVAILABLE
+    DISPATCH_KV_COPY(kBFloat16, __nv_bfloat16);
+#endif
+}

parrot/lib/python3.10/site-packages/deepspeed/inference/v2/kernels/ragged_ops/linear_blocked_kv_rotary/blocked_kv_rotary.cuh

@@ -0,0 +1,47 @@
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0
+
+// DeepSpeed Team
+
+#pragma once
+
+#include "ds_kernel_utils.h"
+#include "ragged_dtypes.h"
+
+#ifdef BF16_AVAILABLE
+#include <cuda_bf16.h>
+#endif
+
+template <typename T>
+void launch_kv_rotary_kernel(T* kv_cache,
+                             T* q,
+                             T* k,
+                             T* v,
+                             T* inv_freq,
+                             const int32_t rotary_dim,
+                             const float theta_base,
+                             const BatchWrapperCPP batch_desc,
+                             const int qkv_stride,
+                             const int kv_cache_stride,
+                             const int v_offset,
+                             const int inv_freq_stride,
+                             const int q_ratio,
+                             const int head_size,
+                             const int n_tokens,
+                             const int n_q_heads,
+                             cudaStream_t stream);
+
+template <typename T>
+void launch_kv_copy_kernel(T* kv_cache,
+                           T* q,
+                           T* k,
+                           T* v,
+                           const BatchWrapperCPP batch_desc,
+                           const int qkv_stride,
+                           const int kv_cache_stride,
+                           const int v_offset,
+                           const int q_ratio,
+                           const int head_size,
+                           const int n_tokens,
+                           const int n_q_heads,
+                           cudaStream_t stream);

parrot/lib/python3.10/site-packages/deepspeed/inference/v2/kernels/ragged_ops/linear_blocked_kv_rotary/blocked_kv_rotary.h

@@ -0,0 +1,65 @@
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0
+
+// DeepSpeed Team
+
+#pragma once
+
+#include <c10/cuda/CUDAStream.h>
+#include <torch/extension.h>
+#include "blocked_kv_rotary.cuh"
+
+/*
+Rotary position embeddings + copy into KV cache. This implementation assumes
+that the inverse frequencies should be ready from global memory rather than
+synthesized in the kernel.
+
+Arguments:
+    kv_cache: [n_blocks, block_size, 2, n_kv_heads, head_size]
+    q: [n_tokens, n_q_heads * head_size]
+    k: [n_tokens, n_kv_heads * head_size]
+    v: [n_tokens, n_kv_heads * head_size]
+    inv_freq: [max_seq_len, head_size // 2]
+*/
+void kv_trained_rotary_embeddings(torch::Tensor& kv_cache,
+                                  torch::Tensor& q,
+                                  torch::Tensor& k,
+                                  torch::Tensor& v,
+                                  torch::Tensor& inv_freq,
+                                  torch::Tensor& batch_metadata,
+                                  torch::Tensor& seq_metadata,
+                                  torch::Tensor& tokens_to_seq,
+                                  torch::Tensor& kv_ptrs);
+
+/*
+Rotary position embeddings + copy into KV cache. This implementation assumes
+that the inverse frequencies should be synthesized in the kernel.
+
+Arguments:
+    kv_cache: [n_blocks, block_size, 2, n_kv_heads, head_size]
+    q: [n_tokens, n_q_heads * head_size]
+    k: [n_tokens, n_kv_heads * head_size]
+    v: [n_tokens, n_kv_heads * head_size]
+*/
+void kv_rotary_embeddings(torch::Tensor& kv_cache,
+                          torch::Tensor& q,
+                          torch::Tensor& k,
+                          torch::Tensor& v,
+                          const int32_t rotary_dim,
+                          const float theta_base,
+                          torch::Tensor& batch_metadata,
+                          torch::Tensor& seq_metadata,
+                          torch::Tensor& tokens_to_seq,
+                          torch::Tensor& kv_ptrs);
+
+/*
+Copy into linear KV cache.
+*/
+void linear_kv_copy(torch::Tensor& kv_cache,
+                    torch::Tensor& q,
+                    torch::Tensor& k,
+                    torch::Tensor& v,
+                    torch::Tensor& batch_metadata,
+                    torch::Tensor& seq_metadata,
+                    torch::Tensor& tokens_to_seq,
+                    torch::Tensor& kv_ptrs);

parrot/lib/python3.10/site-packages/deepspeed/inference/v2/kernels/ragged_ops/linear_blocked_kv_rotary/blocked_kv_rotary.py

@@ -0,0 +1,73 @@
+# Copyright (c) Microsoft Corporation.
+# SPDX-License-Identifier: Apache-2.0
+
+# DeepSpeed Team
+
+import torch
+
+from ....inference_utils import DtypeEnum
+from deepspeed.ops.op_builder import RaggedOpsBuilder
+from ....ragged import RaggedBatchWrapper
+from ... import DSKernelBase
+
+
+class BlockedRotaryEmbeddings(DSKernelBase):
+    """
+    CUDA Kernel implementation that will perform rotary position embeddings on the queries and keys
+    before copying into a blocked KV cache.
+    """
+
+    supported_dtypes = [DtypeEnum.fp16, DtypeEnum.bf16]
+    supported_head_sizes = [64, 80, 128]
+    supported_q_ratios = [1, 2, 4, 5, 8, 16, 29, 35, 36, 71]
+
+    def __init__(self, head_size: int, n_q_heads: int, n_kv_heads: int, dtype: torch.dtype, rotary_dim: int,
+                 theta_base: float) -> None:
+        """
+        Args:
+            head_size: The size of the attention head.
+            q_ratio: Ratio of q heads to kv heads (for GQA)
+            dtype: Data type for the input/output. Supported values are torch.float16 and torch.bfloat16.
+        """
+
+        q_ratio = n_q_heads // n_kv_heads
+
+        if head_size not in BlockedRotaryEmbeddings.supported_head_sizes:
+            raise ValueError("Unsupported head size: {}, supported_head_sizes are {}".format(
+                head_size, BlockedRotaryEmbeddings.supported_head_sizes))
+
+        if q_ratio not in BlockedRotaryEmbeddings.supported_q_ratios:
+            raise ValueError("Unsupported q_ratio: {}, supported_q_ratios are {}".format(
+                q_ratio, BlockedRotaryEmbeddings.supported_q_ratios))
+
+        if not isinstance(dtype, DtypeEnum):
+            dtype = DtypeEnum(dtype)
+
+        if dtype not in BlockedRotaryEmbeddings.supported_dtypes:
+            raise ValueError("Unsupported data type: {}, supported_dtypes are {}".format(
+                dtype, BlockedRotaryEmbeddings.supported_dtypes))
+
+        inf_module = RaggedOpsBuilder().load()
+        self.kernel = inf_module.kv_rotary_embeddings
+        self.head_size = head_size
+        self.n_q_heads = n_q_heads
+        self.n_kv_heads = n_kv_heads
+        self.rotary_dim = rotary_dim
+        self.theta_base = theta_base
+
+    def __call__(self, kv_cache: torch.Tensor, qkv: torch.Tensor, ragged_batch: RaggedBatchWrapper) -> None:
+        """
+        Perform rotary embeddings on the queries and keys before copying into a blocked KV cache.
+
+        Args:
+            kv_cache (torch.Tensor): Pre-allocated KV cache of [num_blocks, block_size, 2, n_kv_heads, head_size]
+            qkv: Input tensor of shape [num_tokens, head_size * (n_q_heads + 2 * n_kv_heads)]
+            ragged_batch: Wrapper for the ragged batch.
+        """
+
+        q = qkv[:, :self.head_size * self.n_q_heads]
+        k = qkv[:, self.head_size * self.n_q_heads:self.head_size * (self.n_q_heads + self.n_kv_heads)]
+        v = qkv[:, self.head_size * (self.n_q_heads + self.n_kv_heads):]
+
+        self.kernel(kv_cache, q, k, v, self.rotary_dim, self.theta_base, ragged_batch.batch_metadata_buffer(),
+                    ragged_batch.inflight_seq_descriptors(), ragged_batch.tokens_to_seq(), ragged_batch.kv_ptrs())

parrot/lib/python3.10/site-packages/deepspeed/inference/v2/kernels/ragged_ops/linear_blocked_kv_rotary/blocked_trained_kv_rotary.py

@@ -0,0 +1,76 @@
+# Copyright (c) Microsoft Corporation.
+# SPDX-License-Identifier: Apache-2.0
+
+# DeepSpeed Team
+
+# Copyright (c) Microsoft Corporation.
+# SPDX-License-Identifier: Apache-2.0
+
+# DeepSpeed Team
+
+import torch
+
+from ....inference_utils import DtypeEnum
+from deepspeed.ops.op_builder import RaggedOpsBuilder
+from ....ragged import RaggedBatchWrapper
+from ... import DSKernelBase
+
+
+class BlockedTrainedRotaryEmbeddings(DSKernelBase):
+    """
+    CUDA Kernel implementation that will perform rotary position embeddings on the queries and keys
+    before copying into a blocked KV cache.
+    """
+
+    supported_dtypes = [DtypeEnum.fp16, DtypeEnum.bf16]
+    supported_head_sizes = [64, 80, 128]
+    supported_q_ratios = [1, 2, 4, 5, 8]
+
+    def __init__(self, head_size: int, n_q_heads: int, n_kv_heads: int, dtype: torch.dtype) -> None:
+        """
+        Args:
+            head_size: The size of the attention head.
+            dtype: Data type for the input/output. Supported values are torch.float16 and torch.bfloat16.
+        """
+
+        q_ratio = n_q_heads // n_kv_heads
+
+        if head_size not in BlockedTrainedRotaryEmbeddings.supported_head_sizes:
+            raise ValueError("Unsupported head size: {}, supported_head_sizes are {}".format(
+                head_size, BlockedTrainedRotaryEmbeddings.supported_head_sizes))
+
+        if q_ratio not in BlockedTrainedRotaryEmbeddings.supported_q_ratios:
+            raise ValueError("Unsupported q_ratio: {}, supported_q_ratios are {}".format(
+                q_ratio, BlockedTrainedRotaryEmbeddings.supported_q_ratios))
+
+        if not isinstance(dtype, DtypeEnum):
+            dtype = DtypeEnum(dtype)
+
+        if dtype not in BlockedTrainedRotaryEmbeddings.supported_dtypes:
+            raise ValueError("Unsupported data type: {}, supported_dtypes are {}".format(
+                dtype, BlockedTrainedRotaryEmbeddings.supported_dtypes))
+
+        inf_module = RaggedOpsBuilder().load()
+        self.kernel = inf_module.kv_trained_rotary_embeddings
+        self.head_size = head_size
+        self.n_q_heads = n_q_heads
+        self.n_kv_heads = n_kv_heads
+
+    def __call__(self, kv_cache: torch.Tensor, qkv: torch.Tensor, ragged_batch: RaggedBatchWrapper,
+                 inverse_freqs: torch.Tensor) -> None:
+        """
+        Perform rotary embeddings on the queries and keys before copying into a blocked KV cache.
+
+        Args:
+            kv_cache (torch.Tensor): Pre-allocated KV cache of [num_blocks, block_size, 2, n_kv_heads, head_size]
+            qkv: Input tensor of shape [num_tokens, head_size * (n_q_heads + 2 * n_kv_heads)]
+            ragged_batch: Wrapper for the ragged batch.
+            inverse_freqs: Inverse frequencies for the rotary embeddings. Shape [max_seq_len, rotary_dim // 2]
+        """
+
+        q = qkv[:, :self.head_size * self.n_q_heads]
+        k = qkv[:, self.head_size * self.n_q_heads:self.head_size * (self.n_q_heads + self.n_kv_heads)]
+        v = qkv[:, self.head_size * (self.n_q_heads + self.n_kv_heads):]
+
+        self.kernel(kv_cache, q, k, v, inverse_freqs, ragged_batch.batch_metadata_buffer(),
+                    ragged_batch.inflight_seq_descriptors(), ragged_batch.tokens_to_seq(), ragged_batch.kv_ptrs())

parrot/lib/python3.10/site-packages/deepspeed/inference/v2/kernels/ragged_ops/logits_gather/logits_gather.cpp

@@ -0,0 +1,45 @@
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0
+
+// DeepSpeed Team
+
+#include "logits_gather.h"
+
+#define DISPATCH_TO_LOGITS_GATHER(T_TYPE, C_TYPE)                  \
+    if (all_acts.options().dtype() == torch::T_TYPE) {             \
+        launch_logits_gather((C_TYPE*)final_token_acts.data_ptr(), \
+                             (const C_TYPE*)all_acts.data_ptr(),   \
+                             batch_metadata_raw,                   \
+                             seq_metadata_raw,                     \
+                             n_seqs,                               \
+                             embed_dim,                            \
+                             at::cuda::getCurrentCUDAStream());    \
+    }
+
+/*
+Logits gather will parse the ragged batch data structure and gather only the logits that
+will be used for token sampling.
+*/
+void gather_for_logits(torch::Tensor& final_token_acts,
+                       torch::Tensor& all_acts,
+                       torch::Tensor& batch_metadata,
+                       torch::Tensor& seq_metadata)
+{
+    const RaggedBatchDescriptor* batch_metadata_raw =
+        reinterpret_cast<const RaggedBatchDescriptor*>(batch_metadata.data_ptr());
+
+    const InflightSeqDescriptor* seq_metadata_raw =
+        reinterpret_cast<const InflightSeqDescriptor*>(seq_metadata.data_ptr());
+
+    const int n_seqs = final_token_acts.size(0);
+    const int embed_dim = final_token_acts.size(1);
+
+    TORCH_CHECK(all_acts.scalar_type() == final_token_acts.scalar_type(),
+                "all_acts and final_token_acts must have the same scalar type");
+
+    DISPATCH_TO_LOGITS_GATHER(kFloat, float)
+    DISPATCH_TO_LOGITS_GATHER(kHalf, half)
+#ifdef BF16_AVAILABLE
+    DISPATCH_TO_LOGITS_GATHER(kBFloat16, __nv_bfloat16)
+#endif
+}

parrot/lib/python3.10/site-packages/deepspeed/inference/v2/kernels/ragged_ops/moe_gather/moe_gather.py

@@ -0,0 +1,53 @@
+# Copyright (c) Microsoft Corporation.
+# SPDX-License-Identifier: Apache-2.0
+
+# DeepSpeed Team
+
+import torch
+
+from ... import DSKernelBase
+from ....inference_utils import DtypeEnum
+from deepspeed.ops.op_builder import RaggedOpsBuilder
+
+
+class MoEGather(DSKernelBase):
+    """
+    CUDA implementation of MoE gather. This will bring the tokens back
+    to their original indices and perform the output scaling.
+    """
+
+    supported_dtypes = [DtypeEnum.fp16, DtypeEnum.bf16]
+
+    def __init__(self, dtype: DtypeEnum, channels: int, normalize_scores: bool = False) -> None:
+
+        if not isinstance(dtype, DtypeEnum):
+            dtype = DtypeEnum(dtype)
+
+        if dtype not in MoEGather.supported_dtypes:
+            raise RuntimeError(f"Unsupported dtype {dtype}")
+
+        if channels % 8 != 0:
+            raise RuntimeError(f"Channels {channels} must be divisible by 8")
+
+        inf_module = RaggedOpsBuilder().load()
+        self.kernel = inf_module.moe_gather
+        self.normalize_scores = normalize_scores
+
+    def __call__(self, layer_output: torch.Tensor, moe_output: torch.Tensor, scores: torch.Tensor,
+                 mapped_slots: torch.Tensor, expert_counts: torch.Tensor) -> torch.Tensor:
+        """
+        Reorders the moe_output tokens into their original order and scales them by their
+        gating scale. This will be a no-op for padded tokens.
+
+        Arguments:
+            layer_output (torch.Tensor): The output of the layer of shape [n_tokens, hidden_size]. This has been scaled appropriately.
+            moe_output (torch.Tensor): The output of the MoE of shape [n_tokens * n_top_k, hidden_size].
+            scores (torch.Tensor): The gating scores of shape [n_tokens].
+            mapped_slots (torch.Tensor): The index of the token in the expert's input of shape [n_tokens, n_top_k]. The indices of token ``i`` in layer_output is ``mapped_slots[i]``.
+            expert_counts (torch.Tensor): The number of tokens assigned to each expert of shape [n_experts]. This is passed to fuse the clearing of this data structure into the gather.
+
+        Returns:
+            layer_output
+        """
+        self.kernel(layer_output, moe_output, scores, mapped_slots, expert_counts, self.normalize_scores)
+        return layer_output

valley/lib/python3.10/site-packages/nvidia/cudnn/lib/libcudnn_ops.so.9

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:242b9dba953ae2e4878d66032624135a9118a1616ca24588ed586d4bcc475c69
+size 108421928

vlmpy310/lib/python3.10/site-packages/skimage/filters/_multiotsu.cpython-310-x86_64-linux-gnu.so

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:801c49b24de8fc0ba1bf08b8b1fbba382818127ed9040037a2a90f68b7155f02
+size 267568

vlmpy310/lib/python3.10/site-packages/skimage/io/_plugins/imageio_plugin.py

@@ -0,0 +1,14 @@
+__all__ = ['imread', 'imsave']
+
+from functools import wraps
+import numpy as np
+
+from imageio.v3 import imread as imageio_imread, imwrite as imsave
+
+
+@wraps(imageio_imread)
+def imread(*args, **kwargs):
+    out = np.asarray(imageio_imread(*args, **kwargs))
+    if not out.flags['WRITEABLE']:
+        out = out.copy()
+    return out

vlmpy310/lib/python3.10/site-packages/skimage/io/_plugins/matplotlib_plugin.py

@@ -0,0 +1,220 @@
+from collections import namedtuple
+import numpy as np
+from ...util import dtype as dtypes
+from ...exposure import is_low_contrast
+from ..._shared.utils import warn
+from math import floor, ceil
+
+
+_default_colormap = 'gray'
+_nonstandard_colormap = 'viridis'
+_diverging_colormap = 'RdBu'
+
+
+ImageProperties = namedtuple(
+    'ImageProperties',
+    ['signed', 'out_of_range_float', 'low_data_range', 'unsupported_dtype'],
+)
+
+
+def _get_image_properties(image):
+    """Determine nonstandard properties of an input image.
+
+    Parameters
+    ----------
+    image : array
+        The input image.
+
+    Returns
+    -------
+    ip : ImageProperties named tuple
+        The properties of the image:
+
+        - signed: whether the image has negative values.
+        - out_of_range_float: if the image has floating point data
+          outside of [-1, 1].
+        - low_data_range: if the image is in the standard image
+          range (e.g. [0, 1] for a floating point image) but its
+          data range would be too small to display with standard
+          image ranges.
+        - unsupported_dtype: if the image data type is not a
+          standard skimage type, e.g. ``numpy.uint64``.
+    """
+    immin, immax = np.min(image), np.max(image)
+    imtype = image.dtype.type
+    try:
+        lo, hi = dtypes.dtype_range[imtype]
+    except KeyError:
+        lo, hi = immin, immax
+
+    signed = immin < 0
+    out_of_range_float = np.issubdtype(image.dtype, np.floating) and (
+        immin < lo or immax > hi
+    )
+    low_data_range = immin != immax and is_low_contrast(image)
+    unsupported_dtype = image.dtype not in dtypes._supported_types
+
+    return ImageProperties(
+        signed, out_of_range_float, low_data_range, unsupported_dtype
+    )
+
+
+def _raise_warnings(image_properties):
+    """Raise the appropriate warning for each nonstandard image type.
+
+    Parameters
+    ----------
+    image_properties : ImageProperties named tuple
+        The properties of the considered image.
+    """
+    ip = image_properties
+    if ip.unsupported_dtype:
+        warn(
+            "Non-standard image type; displaying image with " "stretched contrast.",
+            stacklevel=3,
+        )
+    if ip.low_data_range:
+        warn(
+            "Low image data range; displaying image with " "stretched contrast.",
+            stacklevel=3,
+        )
+    if ip.out_of_range_float:
+        warn(
+            "Float image out of standard range; displaying "
+            "image with stretched contrast.",
+            stacklevel=3,
+        )
+
+
+def _get_display_range(image):
+    """Return the display range for a given set of image properties.
+
+    Parameters
+    ----------
+    image : array
+        The input image.
+
+    Returns
+    -------
+    lo, hi : same type as immin, immax
+        The display range to be used for the input image.
+    cmap : string
+        The name of the colormap to use.
+    """
+    ip = _get_image_properties(image)
+    immin, immax = np.min(image), np.max(image)
+    if ip.signed:
+        magnitude = max(abs(immin), abs(immax))
+        lo, hi = -magnitude, magnitude
+        cmap = _diverging_colormap
+    elif any(ip):
+        _raise_warnings(ip)
+        lo, hi = immin, immax
+        cmap = _nonstandard_colormap
+    else:
+        lo = 0
+        imtype = image.dtype.type
+        hi = dtypes.dtype_range[imtype][1]
+        cmap = _default_colormap
+    return lo, hi, cmap
+
+
+def imshow(image, ax=None, show_cbar=None, **kwargs):
+    """Show the input image and return the current axes.
+
+    By default, the image is displayed in grayscale, rather than
+    the matplotlib default colormap.
+
+    Images are assumed to have standard range for their type. For
+    example, if a floating point image has values in [0, 0.5], the
+    most intense color will be gray50, not white.
+
+    If the image exceeds the standard range, or if the range is too
+    small to display, we fall back on displaying exactly the range of
+    the input image, along with a colorbar to clearly indicate that
+    this range transformation has occurred.
+
+    For signed images, we use a diverging colormap centered at 0.
+
+    Parameters
+    ----------
+    image : array, shape (M, N[, 3])
+        The image to display.
+    ax : `matplotlib.axes.Axes`, optional
+        The axis to use for the image, defaults to plt.gca().
+    show_cbar : boolean, optional.
+        Whether to show the colorbar (used to override default behavior).
+    **kwargs : Keyword arguments
+        These are passed directly to `matplotlib.pyplot.imshow`.
+
+    Returns
+    -------
+    ax_im : `matplotlib.pyplot.AxesImage`
+        The `AxesImage` object returned by `plt.imshow`.
+    """
+    import matplotlib.pyplot as plt
+    from mpl_toolkits.axes_grid1 import make_axes_locatable
+
+    lo, hi, cmap = _get_display_range(image)
+
+    kwargs.setdefault('interpolation', 'nearest')
+    kwargs.setdefault('cmap', cmap)
+    kwargs.setdefault('vmin', lo)
+    kwargs.setdefault('vmax', hi)
+
+    ax = ax or plt.gca()
+    ax_im = ax.imshow(image, **kwargs)
+    if (cmap != _default_colormap and show_cbar is not False) or show_cbar:
+        divider = make_axes_locatable(ax)
+        cax = divider.append_axes("right", size="5%", pad=0.05)
+        plt.colorbar(ax_im, cax=cax)
+    ax.get_figure().tight_layout()
+
+    return ax_im
+
+
+def imshow_collection(ic, *args, **kwargs):
+    """Display all images in the collection.
+
+    Returns
+    -------
+    fig : `matplotlib.figure.Figure`
+        The `Figure` object returned by `plt.subplots`.
+    """
+    import matplotlib.pyplot as plt
+
+    if len(ic) < 1:
+        raise ValueError('Number of images to plot must be greater than 0')
+
+    # The target is to plot images on a grid with aspect ratio 4:3
+    num_images = len(ic)
+    # Two pairs of `nrows, ncols` are possible
+    k = (num_images * 12) ** 0.5
+    r1 = max(1, floor(k / 4))
+    r2 = ceil(k / 4)
+    c1 = ceil(num_images / r1)
+    c2 = ceil(num_images / r2)
+    # Select the one which is closer to 4:3
+    if abs(r1 / c1 - 0.75) < abs(r2 / c2 - 0.75):
+        nrows, ncols = r1, c1
+    else:
+        nrows, ncols = r2, c2
+
+    fig, axes = plt.subplots(nrows=nrows, ncols=ncols)
+    ax = np.asarray(axes).ravel()
+    for n, image in enumerate(ic):
+        ax[n].imshow(image, *args, **kwargs)
+    kwargs['ax'] = axes
+    return fig
+
+
+def imread(*args, **kwargs):
+    import matplotlib.image
+
+    return matplotlib.image.imread(*args, **kwargs)
+
+
+def _app_show():
+    from matplotlib.pyplot import show
+
+    show()

vlmpy310/lib/python3.10/site-packages/skimage/io/_plugins/pil_plugin.ini

@@ -0,0 +1,3 @@
+[pil]
+description = Image reading via the Python Imaging Library
+provides = imread, imsave

vlmpy310/lib/python3.10/site-packages/skimage/io/_plugins/pil_plugin.py

@@ -0,0 +1,261 @@
+__all__ = ['imread', 'imsave']
+
+import numpy as np
+from PIL import Image
+
+from ...util import img_as_ubyte, img_as_uint
+
+
+def imread(fname, dtype=None, img_num=None, **kwargs):
+    """Load an image from file.
+
+    Parameters
+    ----------
+    fname : str or file
+        File name or file-like-object.
+    dtype : numpy dtype object or string specifier
+        Specifies data type of array elements.
+    img_num : int, optional
+        Specifies which image to read in a file with multiple images
+        (zero-indexed).
+    kwargs : keyword pairs, optional
+        Addition keyword arguments to pass through.
+
+    Notes
+    -----
+    Files are read using the Python Imaging Library.
+    See PIL docs [1]_ for a list of supported formats.
+
+    References
+    ----------
+    .. [1] http://pillow.readthedocs.org/en/latest/handbook/image-file-formats.html
+    """
+    if isinstance(fname, str):
+        with open(fname, 'rb') as f:
+            im = Image.open(f)
+            return pil_to_ndarray(im, dtype=dtype, img_num=img_num)
+    else:
+        im = Image.open(fname)
+        return pil_to_ndarray(im, dtype=dtype, img_num=img_num)
+
+
+def pil_to_ndarray(image, dtype=None, img_num=None):
+    """Import a PIL Image object to an ndarray, in memory.
+
+    Parameters
+    ----------
+    Refer to ``imread``.
+
+    """
+    try:
+        # this will raise an IOError if the file is not readable
+        image.getdata()[0]
+    except OSError as e:
+        site = "http://pillow.readthedocs.org/en/latest/installation.html#external-libraries"
+        pillow_error_message = str(e)
+        error_message = (
+            f"Could not load '{image.filename}' \n"
+            f"Reason: '{pillow_error_message}'\n"
+            f"Please see documentation at: {site}"
+        )
+        raise ValueError(error_message)
+    frames = []
+    grayscale = None
+    i = 0
+    while 1:
+        try:
+            image.seek(i)
+        except EOFError:
+            break
+
+        frame = image
+
+        if img_num is not None and img_num != i:
+            image.getdata()[0]
+            i += 1
+            continue
+
+        if image.format == 'PNG' and image.mode == 'I' and dtype is None:
+            dtype = 'uint16'
+
+        if image.mode == 'P':
+            if grayscale is None:
+                grayscale = _palette_is_grayscale(image)
+
+            if grayscale:
+                frame = image.convert('L')
+            else:
+                if image.format == 'PNG' and 'transparency' in image.info:
+                    frame = image.convert('RGBA')
+                else:
+                    frame = image.convert('RGB')
+
+        elif image.mode == '1':
+            frame = image.convert('L')
+
+        elif 'A' in image.mode:
+            frame = image.convert('RGBA')
+
+        elif image.mode == 'CMYK':
+            frame = image.convert('RGB')
+
+        if image.mode.startswith('I;16'):
+            shape = image.size
+            dtype = '>u2' if image.mode.endswith('B') else '<u2'
+            if 'S' in image.mode:
+                dtype = dtype.replace('u', 'i')
+            frame = np.frombuffer(frame.tobytes(), dtype)
+            frame.shape = shape[::-1]
+
+        else:
+            frame = np.array(frame, dtype=dtype)
+
+        frames.append(frame)
+        i += 1
+
+        if img_num is not None:
+            break
+
+    if hasattr(image, 'fp') and image.fp:
+        image.fp.close()
+
+    if img_num is None and len(frames) > 1:
+        return np.array(frames)
+    elif frames:
+        return frames[0]
+    elif img_num:
+        raise IndexError(f'Could not find image  #{img_num}')
+
+
+def _palette_is_grayscale(pil_image):
+    """Return True if PIL image in palette mode is grayscale.
+
+    Parameters
+    ----------
+    pil_image : PIL image
+        PIL Image that is in Palette mode.
+
+    Returns
+    -------
+    is_grayscale : bool
+        True if all colors in image palette are gray.
+    """
+    if pil_image.mode != 'P':
+        raise ValueError('pil_image.mode must be equal to "P".')
+    # get palette as an array with R, G, B columns
+    # Starting in pillow 9.1 palettes may have less than 256 entries
+    palette = np.asarray(pil_image.getpalette()).reshape((-1, 3))
+    # Not all palette colors are used; unused colors have junk values.
+    start, stop = pil_image.getextrema()
+    valid_palette = palette[start : stop + 1]
+    # Image is grayscale if channel differences (R - G and G - B)
+    # are all zero.
+    return np.allclose(np.diff(valid_palette), 0)
+
+
+def ndarray_to_pil(arr, format_str=None):
+    """Export an ndarray to a PIL object.
+
+    Parameters
+    ----------
+    Refer to ``imsave``.
+
+    """
+    if arr.ndim == 3:
+        arr = img_as_ubyte(arr)
+        mode = {3: 'RGB', 4: 'RGBA'}[arr.shape[2]]
+
+    elif format_str in ['png', 'PNG']:
+        mode = 'I;16'
+        mode_base = 'I'
+
+        if arr.dtype.kind == 'f':
+            arr = img_as_uint(arr)
+
+        elif arr.max() < 256 and arr.min() >= 0:
+            arr = arr.astype(np.uint8)
+            mode = mode_base = 'L'
+
+        else:
+            arr = img_as_uint(arr)
+
+    else:
+        arr = img_as_ubyte(arr)
+        mode = 'L'
+        mode_base = 'L'
+
+    try:
+        array_buffer = arr.tobytes()
+    except AttributeError:
+        array_buffer = arr.tostring()  # Numpy < 1.9
+
+    if arr.ndim == 2:
+        im = Image.new(mode_base, arr.T.shape)
+        try:
+            im.frombytes(array_buffer, 'raw', mode)
+        except AttributeError:
+            im.fromstring(array_buffer, 'raw', mode)  # PIL 1.1.7
+    else:
+        image_shape = (arr.shape[1], arr.shape[0])
+        try:
+            im = Image.frombytes(mode, image_shape, array_buffer)
+        except AttributeError:
+            im = Image.fromstring(mode, image_shape, array_buffer)  # PIL 1.1.7
+    return im
+
+
+def imsave(fname, arr, format_str=None, **kwargs):
+    """Save an image to disk.
+
+    Parameters
+    ----------
+    fname : str or file-like object
+        Name of destination file.
+    arr : ndarray of uint8 or float
+        Array (image) to save.  Arrays of data-type uint8 should have
+        values in [0, 255], whereas floating-point arrays must be
+        in [0, 1].
+    format_str: str
+        Format to save as, this is defaulted to PNG if using a file-like
+        object; this will be derived from the extension if fname is a string
+    kwargs: dict
+        Keyword arguments to the Pillow save function (or tifffile save
+        function, for Tiff files). These are format dependent. For example,
+        Pillow's JPEG save function supports an integer ``quality`` argument
+        with values in [1, 95], while TIFFFile supports a ``compress``
+        integer argument with values in [0, 9].
+
+    Notes
+    -----
+    Use the Python Imaging Library.
+    See PIL docs [1]_ for a list of other supported formats.
+    All images besides single channel PNGs are converted using `img_as_uint8`.
+    Single Channel PNGs have the following behavior:
+    - Integer values in [0, 255] and Boolean types -> img_as_uint8
+    - Floating point and other integers -> img_as_uint16
+
+    References
+    ----------
+    .. [1] http://pillow.readthedocs.org/en/latest/handbook/image-file-formats.html
+    """
+    # default to PNG if file-like object
+    if not isinstance(fname, str) and format_str is None:
+        format_str = "PNG"
+    # Check for png in filename
+    if isinstance(fname, str) and fname.lower().endswith(".png"):
+        format_str = "PNG"
+
+    arr = np.asanyarray(arr)
+
+    if arr.dtype.kind == 'b':
+        arr = arr.astype(np.uint8)
+
+    if arr.ndim not in (2, 3):
+        raise ValueError(f"Invalid shape for image array: {arr.shape}")
+
+    if arr.ndim == 3:
+        if arr.shape[2] not in (3, 4):
+            raise ValueError("Invalid number of channels in image array.")
+
+    img = ndarray_to_pil(arr, format_str=format_str)
+    img.save(fname, format=format_str, **kwargs)

vlmpy310/lib/python3.10/site-packages/skimage/io/_plugins/simpleitk_plugin.ini

@@ -0,0 +1,3 @@
+[simpleitk]
+description = Image reading and writing via SimpleITK
+provides = imread, imsave

vlmpy310/lib/python3.10/site-packages/skimage/io/_plugins/tifffile_plugin.ini

@@ -0,0 +1,3 @@
+[tifffile]
+description = Load and save TIFF and TIFF-based images using tifffile.py
+provides = imread, imsave

vlmpy310/lib/python3.10/site-packages/skimage/io/_plugins/tifffile_plugin.py

@@ -0,0 +1,74 @@
+from tifffile import imread as tifffile_imread
+from tifffile import imwrite as tifffile_imwrite
+
+__all__ = ['imread', 'imsave']
+
+
+def imsave(fname, arr, **kwargs):
+    """Load a tiff image to file.
+
+    Parameters
+    ----------
+    fname : str or file
+        File name or file-like object.
+    arr : ndarray
+        The array to write.
+    kwargs : keyword pairs, optional
+        Additional keyword arguments to pass through (see ``tifffile``'s
+        ``imwrite`` function).
+
+    Notes
+    -----
+    Provided by the tifffile library [1]_, and supports many
+    advanced image types including multi-page and floating-point.
+
+    This implementation will set ``photometric='RGB'`` when writing if the first
+    or last axis of `arr` has length 3 or 4. To override this, explicitly
+    pass the ``photometric`` kwarg.
+
+    This implementation will set ``planarconfig='SEPARATE'`` when writing if the
+    first axis of arr has length 3 or 4. To override this, explicitly
+    specify the ``planarconfig`` kwarg.
+
+    References
+    ----------
+    .. [1] https://pypi.org/project/tifffile/
+
+    """
+    if arr.shape[0] in [3, 4]:
+        if 'planarconfig' not in kwargs:
+            kwargs['planarconfig'] = 'SEPARATE'
+        rgb = True
+    else:
+        rgb = arr.shape[-1] in [3, 4]
+    if rgb and 'photometric' not in kwargs:
+        kwargs['photometric'] = 'RGB'
+
+    return tifffile_imwrite(fname, arr, **kwargs)
+
+
+def imread(fname, **kwargs):
+    """Load a tiff image from file.
+
+    Parameters
+    ----------
+    fname : str or file
+        File name or file-like-object.
+    kwargs : keyword pairs, optional
+        Additional keyword arguments to pass through (see ``tifffile``'s
+        ``imread`` function).
+
+    Notes
+    -----
+    Provided by the tifffile library [1]_, and supports many
+    advanced image types including multi-page and floating point.
+
+    References
+    ----------
+    .. [1] https://pypi.org/project/tifffile/
+
+    """
+    if 'img_num' in kwargs:
+        kwargs['key'] = kwargs.pop('img_num')
+
+    return tifffile_imread(fname, **kwargs)

vlmpy310/lib/python3.10/site-packages/skimage/util/__init__.py

@@ -0,0 +1,61 @@
+"""Generic utilities.
+
+This module contains a number of utility functions to work with images in general.
+"""
+
+import functools
+import warnings
+
+import numpy as np
+
+# keep .dtype imports first to avoid circular imports
+from .dtype import (
+    dtype_limits,
+    img_as_float,
+    img_as_float32,
+    img_as_float64,
+    img_as_bool,
+    img_as_int,
+    img_as_ubyte,
+    img_as_uint,
+)
+from ._slice_along_axes import slice_along_axes
+from ._invert import invert
+from ._label import label_points
+from ._montage import montage
+from ._map_array import map_array
+from ._regular_grid import regular_grid, regular_seeds
+from .apply_parallel import apply_parallel
+from .arraycrop import crop
+from .compare import compare_images
+from .noise import random_noise
+from .shape import view_as_blocks, view_as_windows
+from .unique import unique_rows
+from .lookfor import lookfor
+
+
+__all__ = [
+    'img_as_float32',
+    'img_as_float64',
+    'img_as_float',
+    'img_as_int',
+    'img_as_uint',
+    'img_as_ubyte',
+    'img_as_bool',
+    'dtype_limits',
+    'view_as_blocks',
+    'view_as_windows',
+    'slice_along_axes',
+    'crop',
+    'compare_images',
+    'map_array',
+    'montage',
+    'random_noise',
+    'regular_grid',
+    'regular_seeds',
+    'apply_parallel',
+    'invert',
+    'unique_rows',
+    'label_points',
+    'lookfor',
+]

vlmpy310/lib/python3.10/site-packages/skimage/util/_invert.py

@@ -0,0 +1,74 @@
+import numpy as np
+from .dtype import dtype_limits
+
+
+def invert(image, signed_float=False):
+    """Invert an image.
+
+    Invert the intensity range of the input image, so that the dtype maximum
+    is now the dtype minimum, and vice-versa. This operation is
+    slightly different depending on the input dtype:
+
+    - unsigned integers: subtract the image from the dtype maximum
+    - signed integers: subtract the image from -1 (see Notes)
+    - floats: subtract the image from 1 (if signed_float is False, so we
+      assume the image is unsigned), or from 0 (if signed_float is True).
+
+    See the examples for clarification.
+
+    Parameters
+    ----------
+    image : ndarray
+        Input image.
+    signed_float : bool, optional
+        If True and the image is of type float, the range is assumed to
+        be [-1, 1]. If False and the image is of type float, the range is
+        assumed to be [0, 1].
+
+    Returns
+    -------
+    inverted : ndarray
+        Inverted image.
+
+    Notes
+    -----
+    Ideally, for signed integers we would simply multiply by -1. However,
+    signed integer ranges are asymmetric. For example, for np.int8, the range
+    of possible values is [-128, 127], so that -128 * -1 equals -128! By
+    subtracting from -1, we correctly map the maximum dtype value to the
+    minimum.
+
+    Examples
+    --------
+    >>> img = np.array([[100,  0, 200],
+    ...                 [  0, 50,   0],
+    ...                 [ 30,  0, 255]], np.uint8)
+    >>> invert(img)
+    array([[155, 255,  55],
+           [255, 205, 255],
+           [225, 255,   0]], dtype=uint8)
+    >>> img2 = np.array([[ -2, 0, -128],
+    ...                  [127, 0,    5]], np.int8)
+    >>> invert(img2)
+    array([[   1,   -1,  127],
+           [-128,   -1,   -6]], dtype=int8)
+    >>> img3 = np.array([[ 0., 1., 0.5, 0.75]])
+    >>> invert(img3)
+    array([[1.  , 0.  , 0.5 , 0.25]])
+    >>> img4 = np.array([[ 0., 1., -1., -0.25]])
+    >>> invert(img4, signed_float=True)
+    array([[-0.  , -1.  ,  1.  ,  0.25]])
+    """
+    if image.dtype == 'bool':
+        inverted = ~image
+    elif np.issubdtype(image.dtype, np.unsignedinteger):
+        max_val = dtype_limits(image, clip_negative=False)[1]
+        inverted = np.subtract(max_val, image, dtype=image.dtype)
+    elif np.issubdtype(image.dtype, np.signedinteger):
+        inverted = np.subtract(-1, image, dtype=image.dtype)
+    else:  # float dtype
+        if signed_float:
+            inverted = -image
+        else:
+            inverted = np.subtract(1, image, dtype=image.dtype)
+    return inverted

vlmpy310/lib/python3.10/site-packages/skimage/util/_label.py

@@ -0,0 +1,51 @@
+import numpy as np
+
+__all__ = ["label_points"]
+
+
+def label_points(coords, output_shape):
+    """Assign unique integer labels to coordinates on an image mask
+
+    Parameters
+    ----------
+    coords: ndarray
+        An array of N coordinates with dimension D
+    output_shape: tuple
+        The shape of the mask on which `coords` are labelled
+
+    Returns
+    -------
+    labels: ndarray
+        A mask of zeroes containing unique integer labels at the `coords`
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> from skimage.util._label import label_points
+    >>> coords = np.array([[0, 1], [2, 2]])
+    >>> output_shape = (5, 5)
+    >>> mask = label_points(coords, output_shape)
+    >>> mask
+    array([[0, 1, 0, 0, 0],
+           [0, 0, 0, 0, 0],
+           [0, 0, 2, 0, 0],
+           [0, 0, 0, 0, 0],
+           [0, 0, 0, 0, 0]], dtype=uint64)
+
+    Notes
+    -----
+    - The labels are assigned to coordinates that are converted to
+      integer and considered to start from 0.
+    - Coordinates that are out of range of the mask raise an IndexError.
+    - Negative coordinates raise a ValueError
+    """
+    if coords.shape[1] != len(output_shape):
+        raise ValueError("Dimensionality of points should match the " "output shape")
+
+    if np.any(coords < 0):
+        raise ValueError("Coordinates should be positive and start from 0")
+
+    np_indices = tuple(np.transpose(np.round(coords).astype(int, copy=False)))
+    labels = np.zeros(output_shape, dtype=np.uint64)
+    labels[np_indices] = np.arange(1, coords.shape[0] + 1)
+    return labels

vlmpy310/lib/python3.10/site-packages/skimage/util/_map_array.py

@@ -0,0 +1,199 @@
+import numpy as np
+
+
+def map_array(input_arr, input_vals, output_vals, out=None):
+    """Map values from input array from input_vals to output_vals.
+
+    Parameters
+    ----------
+    input_arr : array of int, shape (M[, ...])
+        The input label image.
+    input_vals : array of int, shape (K,)
+        The values to map from.
+    output_vals : array, shape (K,)
+        The values to map to.
+    out: array, same shape as `input_arr`
+        The output array. Will be created if not provided. It should
+        have the same dtype as `output_vals`.
+
+    Returns
+    -------
+    out : array, same shape as `input_arr`
+        The array of mapped values.
+
+    Notes
+    -----
+    If `input_arr` contains values that aren't covered by `input_vals`, they
+    are set to 0.
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> import skimage as ski
+    >>> ski.util.map_array(
+    ...    input_arr=np.array([[0, 2, 2, 0], [3, 4, 5, 0]]),
+    ...    input_vals=np.array([1, 2, 3, 4, 6]),
+    ...    output_vals=np.array([6, 7, 8, 9, 10]),
+    ... )
+    array([[0, 7, 7, 0],
+           [8, 9, 0, 0]])
+    """
+    from ._remap import _map_array
+
+    if not np.issubdtype(input_arr.dtype, np.integer):
+        raise TypeError('The dtype of an array to be remapped should be integer.')
+    # We ravel the input array for simplicity of iteration in Cython:
+    orig_shape = input_arr.shape
+    # NumPy docs for `np.ravel()` says:
+    # "When a view is desired in as many cases as possible,
+    # arr.reshape(-1) may be preferable."
+    input_arr = input_arr.reshape(-1)
+    if out is None:
+        out = np.empty(orig_shape, dtype=output_vals.dtype)
+    elif out.shape != orig_shape:
+        raise ValueError(
+            'If out array is provided, it should have the same shape as '
+            f'the input array. Input array has shape {orig_shape}, provided '
+            f'output array has shape {out.shape}.'
+        )
+    try:
+        out_view = out.view()
+        out_view.shape = (-1,)  # no-copy reshape/ravel
+    except AttributeError:  # if out strides are not compatible with 0-copy
+        raise ValueError(
+            'If out array is provided, it should be either contiguous '
+            f'or 1-dimensional. Got array with shape {out.shape} and '
+            f'strides {out.strides}.'
+        )
+
+    # ensure all arrays have matching types before sending to Cython
+    input_vals = input_vals.astype(input_arr.dtype, copy=False)
+    output_vals = output_vals.astype(out.dtype, copy=False)
+    _map_array(input_arr, out_view, input_vals, output_vals)
+    return out
+
+
+class ArrayMap:
+    """Class designed to mimic mapping by NumPy array indexing.
+
+    This class is designed to replicate the use of NumPy arrays for mapping
+    values with indexing:
+
+    >>> values = np.array([0.25, 0.5, 1.0])
+    >>> indices = np.array([[0, 0, 1], [2, 2, 1]])
+    >>> values[indices]
+    array([[0.25, 0.25, 0.5 ],
+           [1.  , 1.  , 0.5 ]])
+
+    The issue with this indexing is that you need a very large ``values``
+    array if the values in the ``indices`` array are large.
+
+    >>> values = np.array([0.25, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1.0])
+    >>> indices = np.array([[0, 0, 10], [0, 10, 10]])
+    >>> values[indices]
+    array([[0.25, 0.25, 1.  ],
+           [0.25, 1.  , 1.  ]])
+
+    Using this class, the approach is similar, but there is no need to
+    create a large values array:
+
+    >>> in_indices = np.array([0, 10])
+    >>> out_values = np.array([0.25, 1.0])
+    >>> values = ArrayMap(in_indices, out_values)
+    >>> values
+    ArrayMap(array([ 0, 10]), array([0.25, 1.  ]))
+    >>> print(values)
+    ArrayMap:
+      0 → 0.25
+      10 → 1.0
+    >>> indices = np.array([[0, 0, 10], [0, 10, 10]])
+    >>> values[indices]
+    array([[0.25, 0.25, 1.  ],
+           [0.25, 1.  , 1.  ]])
+
+    Parameters
+    ----------
+    in_values : array of int, shape (K,)
+        The source values from which to map.
+    out_values : array, shape (K,)
+        The destination values from which to map.
+    """
+
+    def __init__(self, in_values, out_values):
+        self.in_values = in_values
+        self.out_values = out_values
+        self._max_str_lines = 4
+        self._array = None
+
+    def __len__(self):
+        """Return one more than the maximum label value being remapped."""
+        return np.max(self.in_values) + 1
+
+    def __array__(self, dtype=None, copy=None):
+        """Return an array that behaves like the arraymap when indexed.
+
+        This array can be very large: it is the size of the largest value
+        in the ``in_vals`` array, plus one.
+        """
+        if dtype is None:
+            dtype = self.out_values.dtype
+        output = np.zeros(np.max(self.in_values) + 1, dtype=dtype)
+        output[self.in_values] = self.out_values
+        return output
+
+    @property
+    def dtype(self):
+        return self.out_values.dtype
+
+    def __repr__(self):
+        return f'ArrayMap({repr(self.in_values)}, {repr(self.out_values)})'
+
+    def __str__(self):
+        if len(self.in_values) <= self._max_str_lines + 1:
+            rows = range(len(self.in_values))
+            string = '\n'.join(
+                ['ArrayMap:']
+                + [f'  {self.in_values[i]} → {self.out_values[i]}' for i in rows]
+            )
+        else:
+            rows0 = list(range(0, self._max_str_lines // 2))
+            rows1 = list(range(-self._max_str_lines // 2, 0))
+            string = '\n'.join(
+                ['ArrayMap:']
+                + [f'  {self.in_values[i]} → {self.out_values[i]}' for i in rows0]
+                + ['  ...']
+                + [f'  {self.in_values[i]} → {self.out_values[i]}' for i in rows1]
+            )
+        return string
+
+    def __call__(self, arr):
+        return self.__getitem__(arr)
+
+    def __getitem__(self, index):
+        scalar = np.isscalar(index)
+        if scalar:
+            index = np.array([index])
+        elif isinstance(index, slice):
+            start = index.start or 0  # treat None or 0 the same way
+            stop = index.stop if index.stop is not None else len(self)
+            step = index.step
+            index = np.arange(start, stop, step)
+        if index.dtype == bool:
+            index = np.flatnonzero(index)
+
+        out = map_array(
+            index,
+            self.in_values.astype(index.dtype, copy=False),
+            self.out_values,
+        )
+
+        if scalar:
+            out = out[0]
+        return out
+
+    def __setitem__(self, indices, values):
+        if self._array is None:
+            self._array = self.__array__()
+        self._array[indices] = values
+        self.in_values = np.flatnonzero(self._array)
+        self.out_values = self._array[self.in_values]

vlmpy310/lib/python3.10/site-packages/skimage/util/_montage.py

@@ -0,0 +1,158 @@
+import numpy as np
+
+from .._shared import utils
+from .. import exposure
+
+__all__ = ['montage']
+
+
+@utils.channel_as_last_axis(multichannel_output=False)
+def montage(
+    arr_in,
+    fill='mean',
+    rescale_intensity=False,
+    grid_shape=None,
+    padding_width=0,
+    *,
+    channel_axis=None,
+):
+    """Create a montage of several single- or multichannel images.
+
+    Create a rectangular montage from an input array representing an ensemble
+    of equally shaped single- (gray) or multichannel (color) images.
+
+    For example, ``montage(arr_in)`` called with the following `arr_in`
+
+    +---+---+---+
+    | 1 | 2 | 3 |
+    +---+---+---+
+
+    will return
+
+    +---+---+
+    | 1 | 2 |
+    +---+---+
+    | 3 | * |
+    +---+---+
+
+    where the '*' patch will be determined by the `fill` parameter.
+
+    Parameters
+    ----------
+    arr_in : ndarray, shape (K, M, N[, C])
+        An array representing an ensemble of `K` images of equal shape.
+    fill : float or array-like of floats or 'mean', optional
+        Value to fill the padding areas and/or the extra tiles in
+        the output array. Has to be `float` for single channel collections.
+        For multichannel collections has to be an array-like of shape of
+        number of channels. If `mean`, uses the mean value over all images.
+    rescale_intensity : bool, optional
+        Whether to rescale the intensity of each image to [0, 1].
+    grid_shape : tuple, optional
+        The desired grid shape for the montage `(ntiles_row, ntiles_column)`.
+        The default aspect ratio is square.
+    padding_width : int, optional
+        The size of the spacing between the tiles and between the tiles and
+        the borders. If non-zero, makes the boundaries of individual images
+        easier to perceive.
+    channel_axis : int or None, optional
+        If None, the image is assumed to be a grayscale (single channel) image.
+        Otherwise, this parameter indicates which axis of the array corresponds
+        to channels.
+
+    Returns
+    -------
+    arr_out : (K*(M+p)+p, K*(N+p)+p[, C]) ndarray
+        Output array with input images glued together (including padding `p`).
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> from skimage.util import montage
+    >>> arr_in = np.arange(3 * 2 * 2).reshape(3, 2, 2)
+    >>> arr_in  # doctest: +NORMALIZE_WHITESPACE
+    array([[[ 0,  1],
+            [ 2,  3]],
+           [[ 4,  5],
+            [ 6,  7]],
+           [[ 8,  9],
+            [10, 11]]])
+    >>> arr_out = montage(arr_in)
+    >>> arr_out.shape
+    (4, 4)
+    >>> arr_out
+    array([[ 0,  1,  4,  5],
+           [ 2,  3,  6,  7],
+           [ 8,  9,  5,  5],
+           [10, 11,  5,  5]])
+    >>> arr_in.mean()
+    5.5
+    >>> arr_out_nonsquare = montage(arr_in, grid_shape=(1, 3))
+    >>> arr_out_nonsquare
+    array([[ 0,  1,  4,  5,  8,  9],
+           [ 2,  3,  6,  7, 10, 11]])
+    >>> arr_out_nonsquare.shape
+    (2, 6)
+    """
+
+    if channel_axis is not None:
+        arr_in = np.asarray(arr_in)
+    else:
+        arr_in = np.asarray(arr_in)[..., np.newaxis]
+
+    if arr_in.ndim != 4:
+        raise ValueError(
+            'Input array has to be 3-dimensional for grayscale '
+            'images, or 4-dimensional with a `channel_axis` '
+            'specified.'
+        )
+
+    n_images, n_rows, n_cols, n_chan = arr_in.shape
+
+    if grid_shape:
+        ntiles_row, ntiles_col = (int(s) for s in grid_shape)
+    else:
+        ntiles_row = ntiles_col = int(np.ceil(np.sqrt(n_images)))
+
+    # Rescale intensity if necessary
+    if rescale_intensity:
+        for i in range(n_images):
+            arr_in[i] = exposure.rescale_intensity(arr_in[i])
+
+    # Calculate the fill value
+    if fill == 'mean':
+        fill = arr_in.mean(axis=(0, 1, 2))
+    fill = np.atleast_1d(fill).astype(arr_in.dtype)
+
+    # Pre-allocate an array with padding for montage
+    n_pad = padding_width
+    arr_out = np.empty(
+        (
+            (n_rows + n_pad) * ntiles_row + n_pad,
+            (n_cols + n_pad) * ntiles_col + n_pad,
+            n_chan,
+        ),
+        dtype=arr_in.dtype,
+    )
+    for idx_chan in range(n_chan):
+        arr_out[..., idx_chan] = fill[idx_chan]
+
+    slices_row = [
+        slice(n_pad + (n_rows + n_pad) * n, n_pad + (n_rows + n_pad) * n + n_rows)
+        for n in range(ntiles_row)
+    ]
+    slices_col = [
+        slice(n_pad + (n_cols + n_pad) * n, n_pad + (n_cols + n_pad) * n + n_cols)
+        for n in range(ntiles_col)
+    ]
+
+    # Copy the data to the output array
+    for idx_image, image in enumerate(arr_in):
+        idx_sr = idx_image // ntiles_col
+        idx_sc = idx_image % ntiles_col
+        arr_out[slices_row[idx_sr], slices_col[idx_sc], :] = image
+
+    if channel_axis is not None:
+        return arr_out
+    else:
+        return arr_out[..., 0]

vlmpy310/lib/python3.10/site-packages/skimage/util/_regular_grid.py

@@ -0,0 +1,114 @@
+import numpy as np
+
+
+def regular_grid(ar_shape, n_points):
+    """Find `n_points` regularly spaced along `ar_shape`.
+
+    The returned points (as slices) should be as close to cubically-spaced as
+    possible. Essentially, the points are spaced by the Nth root of the input
+    array size, where N is the number of dimensions. However, if an array
+    dimension cannot fit a full step size, it is "discarded", and the
+    computation is done for only the remaining dimensions.
+
+    Parameters
+    ----------
+    ar_shape : array-like of ints
+        The shape of the space embedding the grid. ``len(ar_shape)`` is the
+        number of dimensions.
+    n_points : int
+        The (approximate) number of points to embed in the space.
+
+    Returns
+    -------
+    slices : tuple of slice objects
+        A slice along each dimension of `ar_shape`, such that the intersection
+        of all the slices give the coordinates of regularly spaced points.
+
+        .. versionchanged:: 0.14.1
+            In scikit-image 0.14.1 and 0.15, the return type was changed from a
+            list to a tuple to ensure `compatibility with Numpy 1.15`_ and
+            higher. If your code requires the returned result to be a list, you
+            may convert the output of this function to a list with:
+
+            >>> result = list(regular_grid(ar_shape=(3, 20, 40), n_points=8))
+
+            .. _compatibility with NumPy 1.15: https://github.com/numpy/numpy/blob/master/doc/release/1.15.0-notes.rst#deprecations
+
+    Examples
+    --------
+    >>> ar = np.zeros((20, 40))
+    >>> g = regular_grid(ar.shape, 8)
+    >>> g
+    (slice(5, None, 10), slice(5, None, 10))
+    >>> ar[g] = 1
+    >>> ar.sum()
+    8.0
+    >>> ar = np.zeros((20, 40))
+    >>> g = regular_grid(ar.shape, 32)
+    >>> g
+    (slice(2, None, 5), slice(2, None, 5))
+    >>> ar[g] = 1
+    >>> ar.sum()
+    32.0
+    >>> ar = np.zeros((3, 20, 40))
+    >>> g = regular_grid(ar.shape, 8)
+    >>> g
+    (slice(1, None, 3), slice(5, None, 10), slice(5, None, 10))
+    >>> ar[g] = 1
+    >>> ar.sum()
+    8.0
+    """
+    ar_shape = np.asanyarray(ar_shape)
+    ndim = len(ar_shape)
+    unsort_dim_idxs = np.argsort(np.argsort(ar_shape))
+    sorted_dims = np.sort(ar_shape)
+    space_size = float(np.prod(ar_shape))
+    if space_size <= n_points:
+        return (slice(None),) * ndim
+    stepsizes = np.full(ndim, (space_size / n_points) ** (1.0 / ndim), dtype='float64')
+    if (sorted_dims < stepsizes).any():
+        for dim in range(ndim):
+            stepsizes[dim] = sorted_dims[dim]
+            space_size = float(np.prod(sorted_dims[dim + 1 :]))
+            stepsizes[dim + 1 :] = (space_size / n_points) ** (1.0 / (ndim - dim - 1))
+            if (sorted_dims >= stepsizes).all():
+                break
+    starts = (stepsizes // 2).astype(int)
+    stepsizes = np.round(stepsizes).astype(int)
+    slices = [slice(start, None, step) for start, step in zip(starts, stepsizes)]
+    slices = tuple(slices[i] for i in unsort_dim_idxs)
+    return slices
+
+
+def regular_seeds(ar_shape, n_points, dtype=int):
+    """Return an image with ~`n_points` regularly-spaced nonzero pixels.
+
+    Parameters
+    ----------
+    ar_shape : tuple of int
+        The shape of the desired output image.
+    n_points : int
+        The desired number of nonzero points.
+    dtype : numpy data type, optional
+        The desired data type of the output.
+
+    Returns
+    -------
+    seed_img : array of int or bool
+        The desired image.
+
+    Examples
+    --------
+    >>> regular_seeds((5, 5), 4)
+    array([[0, 0, 0, 0, 0],
+           [0, 1, 0, 2, 0],
+           [0, 0, 0, 0, 0],
+           [0, 3, 0, 4, 0],
+           [0, 0, 0, 0, 0]])
+    """
+    grid = regular_grid(ar_shape, n_points)
+    seed_img = np.zeros(ar_shape, dtype=dtype)
+    seed_img[grid] = 1 + np.reshape(
+        np.arange(seed_img[grid].size), seed_img[grid].shape
+    )
+    return seed_img

vlmpy310/lib/python3.10/site-packages/skimage/util/_slice_along_axes.py

@@ -0,0 +1,86 @@
+__all__ = ['slice_along_axes']
+
+
+def slice_along_axes(image, slices, axes=None, copy=False):
+    """Slice an image along given axes.
+
+    Parameters
+    ----------
+    image : ndarray
+        Input image.
+    slices : list of 2-tuple (a, b) where a < b.
+        For each axis in `axes`, a corresponding 2-tuple
+        ``(min_val, max_val)`` to slice with (as with Python slices,
+        ``max_val`` is non-inclusive).
+    axes : int or tuple, optional
+        Axes corresponding to the limits given in `slices`. If None,
+        axes are in ascending order, up to the length of `slices`.
+    copy : bool, optional
+        If True, ensure that the output is not a view of `image`.
+
+    Returns
+    -------
+    out : ndarray
+        The region of `image` corresponding to the given slices and axes.
+
+    Examples
+    --------
+    >>> from skimage import data
+    >>> img = data.camera()
+    >>> img.shape
+    (512, 512)
+    >>> cropped_img = slice_along_axes(img, [(0, 100)])
+    >>> cropped_img.shape
+    (100, 512)
+    >>> cropped_img = slice_along_axes(img, [(0, 100), (0, 100)])
+    >>> cropped_img.shape
+    (100, 100)
+    >>> cropped_img = slice_along_axes(img, [(0, 100), (0, 75)], axes=[1, 0])
+    >>> cropped_img.shape
+    (75, 100)
+    """
+
+    # empty length of bounding box detected on None
+    if not slices:
+        return image
+
+    if axes is None:
+        axes = list(range(image.ndim))
+        if len(axes) < len(slices):
+            raise ValueError("More `slices` than available axes")
+
+    elif len(axes) != len(slices):
+        raise ValueError("`axes` and `slices` must have equal length")
+
+    if len(axes) != len(set(axes)):
+        raise ValueError("`axes` must be unique")
+
+    if not all(a >= 0 and a < image.ndim for a in axes):
+        raise ValueError(
+            f"axes {axes} out of range; image has only " f"{image.ndim} dimensions"
+        )
+
+    _slices = [
+        slice(None),
+    ] * image.ndim
+    for (a, b), ax in zip(slices, axes):
+        if a < 0:
+            a %= image.shape[ax]
+        if b < 0:
+            b %= image.shape[ax]
+        if a > b:
+            raise ValueError(
+                f"Invalid slice ({a}, {b}): must be ordered `(min_val, max_val)`"
+            )
+        if a < 0 or b > image.shape[ax]:
+            raise ValueError(
+                f"Invalid slice ({a}, {b}) for image with dimensions {image.shape}"
+            )
+        _slices[ax] = slice(a, b)
+
+    image_slice = image[tuple(_slices)]
+
+    if copy and image_slice.base is not None:
+        image_slice = image_slice.copy()
+
+    return image_slice

vlmpy310/lib/python3.10/site-packages/skimage/util/apply_parallel.py

@@ -0,0 +1,213 @@
+import numpy
+
+__all__ = ['apply_parallel']
+
+
+def _get_chunks(shape, ncpu):
+    """Split the array into equal sized chunks based on the number of
+    available processors. The last chunk in each dimension absorbs the
+    remainder array elements if the number of CPUs does not divide evenly into
+    the number of array elements.
+
+    Examples
+    --------
+    >>> _get_chunks((4, 4), 4)
+    ((2, 2), (2, 2))
+    >>> _get_chunks((4, 4), 2)
+    ((2, 2), (4,))
+    >>> _get_chunks((5, 5), 2)
+    ((2, 3), (5,))
+    >>> _get_chunks((2, 4), 2)
+    ((1, 1), (4,))
+    """
+    # since apply_parallel is in the critical import path, we lazy import
+    # math just when we need it.
+    from math import ceil
+
+    chunks = []
+    nchunks_per_dim = int(ceil(ncpu ** (1.0 / len(shape))))
+
+    used_chunks = 1
+    for i in shape:
+        if used_chunks < ncpu:
+            regular_chunk = i // nchunks_per_dim
+            remainder_chunk = regular_chunk + (i % nchunks_per_dim)
+
+            if regular_chunk == 0:
+                chunk_lens = (remainder_chunk,)
+            else:
+                chunk_lens = (regular_chunk,) * (nchunks_per_dim - 1) + (
+                    remainder_chunk,
+                )
+        else:
+            chunk_lens = (i,)
+
+        chunks.append(chunk_lens)
+        used_chunks *= nchunks_per_dim
+    return tuple(chunks)
+
+
+def _ensure_dask_array(array, chunks=None):
+    import dask.array as da
+
+    if isinstance(array, da.Array):
+        return array
+
+    return da.from_array(array, chunks=chunks)
+
+
+def apply_parallel(
+    function,
+    array,
+    chunks=None,
+    depth=0,
+    mode=None,
+    extra_arguments=(),
+    extra_keywords=None,
+    *,
+    dtype=None,
+    compute=None,
+    channel_axis=None,
+):
+    """Map a function in parallel across an array.
+
+    Split an array into possibly overlapping chunks of a given depth and
+    boundary type, call the given function in parallel on the chunks, combine
+    the chunks and return the resulting array.
+
+    Parameters
+    ----------
+    function : function
+        Function to be mapped which takes an array as an argument.
+    array : numpy array or dask array
+        Array which the function will be applied to.
+    chunks : int, tuple, or tuple of tuples, optional
+        A single integer is interpreted as the length of one side of a square
+        chunk that should be tiled across the array.  One tuple of length
+        ``array.ndim`` represents the shape of a chunk, and it is tiled across
+        the array.  A list of tuples of length ``ndim``, where each sub-tuple
+        is a sequence of chunk sizes along the corresponding dimension. If
+        None, the array is broken up into chunks based on the number of
+        available cpus. More information about chunks is in the documentation
+        `here <https://dask.pydata.org/en/latest/array-design.html>`_. When
+        `channel_axis` is not None, the tuples can be length ``ndim - 1`` and
+        a single chunk will be used along the channel axis.
+    depth : int or sequence of int, optional
+        The depth of the added boundary cells. A tuple can be used to specify a
+        different depth per array axis. Defaults to zero. When `channel_axis`
+        is not None, and a tuple of length ``ndim - 1`` is provided, a depth of
+        0 will be used along the channel axis.
+    mode : {'reflect', 'symmetric', 'periodic', 'wrap', 'nearest', 'edge'}, optional
+        Type of external boundary padding.
+    extra_arguments : tuple, optional
+        Tuple of arguments to be passed to the function.
+    extra_keywords : dictionary, optional
+        Dictionary of keyword arguments to be passed to the function.
+    dtype : data-type or None, optional
+        The data-type of the `function` output. If None, Dask will attempt to
+        infer this by calling the function on data of shape ``(1,) * ndim``.
+        For functions expecting RGB or multichannel data this may be
+        problematic. In such cases, the user should manually specify this dtype
+        argument instead.
+
+        .. versionadded:: 0.18
+           ``dtype`` was added in 0.18.
+    compute : bool, optional
+        If ``True``, compute eagerly returning a NumPy Array.
+        If ``False``, compute lazily returning a Dask Array.
+        If ``None`` (default), compute based on array type provided
+        (eagerly for NumPy Arrays and lazily for Dask Arrays).
+    channel_axis : int or None, optional
+        If None, the image is assumed to be a grayscale (single channel) image.
+        Otherwise, this parameter indicates which axis of the array corresponds
+        to channels.
+
+    Returns
+    -------
+    out : ndarray or dask Array
+        Returns the result of the applying the operation.
+        Type is dependent on the ``compute`` argument.
+
+    Notes
+    -----
+    Numpy edge modes 'symmetric', 'wrap', and 'edge' are converted to the
+    equivalent ``dask`` boundary modes 'reflect', 'periodic' and 'nearest',
+    respectively.
+    Setting ``compute=False`` can be useful for chaining later operations.
+    For example region selection to preview a result or storing large data
+    to disk instead of loading in memory.
+
+    """
+    try:
+        # Importing dask takes time. since apply_parallel is on the
+        # minimum import path of skimage, we lazy attempt to import dask
+        import dask.array as da
+    except ImportError:
+        raise RuntimeError(
+            "Could not import 'dask'.  Please install " "using 'pip install dask'"
+        )
+
+    if extra_keywords is None:
+        extra_keywords = {}
+
+    if compute is None:
+        compute = not isinstance(array, da.Array)
+
+    if channel_axis is not None:
+        channel_axis = channel_axis % array.ndim
+
+    if chunks is None:
+        shape = array.shape
+        try:
+            # since apply_parallel is in the critical import path, we lazy
+            # import multiprocessing just when we need it.
+            from multiprocessing import cpu_count
+
+            ncpu = cpu_count()
+        except NotImplementedError:
+            ncpu = 4
+        if channel_axis is not None:
+            # use a single chunk along the channel axis
+            spatial_shape = shape[:channel_axis] + shape[channel_axis + 1 :]
+            chunks = list(_get_chunks(spatial_shape, ncpu))
+            chunks.insert(channel_axis, shape[channel_axis])
+            chunks = tuple(chunks)
+        else:
+            chunks = _get_chunks(shape, ncpu)
+    elif channel_axis is not None and len(chunks) == array.ndim - 1:
+        # insert a single chunk along the channel axis
+        chunks = list(chunks)
+        chunks.insert(channel_axis, array.shape[channel_axis])
+        chunks = tuple(chunks)
+
+    if mode == 'wrap':
+        mode = 'periodic'
+    elif mode == 'symmetric':
+        mode = 'reflect'
+    elif mode == 'edge':
+        mode = 'nearest'
+    elif mode is None:
+        # default value for Dask.
+        # Note: that for dask >= 2022.03 it will change to 'none' so we set it
+        #       here for consistent behavior across Dask versions.
+        mode = 'reflect'
+
+    if channel_axis is not None:
+        if numpy.isscalar(depth):
+            # depth is zero along channel_axis
+            depth = [depth] * (array.ndim - 1)
+        depth = list(depth)
+        if len(depth) == array.ndim - 1:
+            depth.insert(channel_axis, 0)
+        depth = tuple(depth)
+
+    def wrapped_func(arr):
+        return function(arr, *extra_arguments, **extra_keywords)
+
+    darr = _ensure_dask_array(array, chunks=chunks)
+
+    res = darr.map_overlap(wrapped_func, depth, boundary=mode, dtype=dtype)
+    if compute:
+        res = res.compute()
+
+    return res

vlmpy310/lib/python3.10/site-packages/skimage/util/arraycrop.py

@@ -0,0 +1,72 @@
+"""
+The arraycrop module contains functions to crop values from the edges of an
+n-dimensional array.
+"""
+
+import numpy as np
+from numbers import Integral
+
+__all__ = ['crop']
+
+
+def crop(ar, crop_width, copy=False, order='K'):
+    """Crop array `ar` by `crop_width` along each dimension.
+
+    Parameters
+    ----------
+    ar : array-like of rank N
+        Input array.
+    crop_width : {sequence, int}
+        Number of values to remove from the edges of each axis.
+        ``((before_1, after_1),`` ... ``(before_N, after_N))`` specifies
+        unique crop widths at the start and end of each axis.
+        ``((before, after),) or (before, after)`` specifies
+        a fixed start and end crop for every axis.
+        ``(n,)`` or ``n`` for integer ``n`` is a shortcut for
+        before = after = ``n`` for all axes.
+    copy : bool, optional
+        If `True`, ensure the returned array is a contiguous copy. Normally,
+        a crop operation will return a discontiguous view of the underlying
+        input array.
+    order : {'C', 'F', 'A', 'K'}, optional
+        If ``copy==True``, control the memory layout of the copy. See
+        ``np.copy``.
+
+    Returns
+    -------
+    cropped : array
+        The cropped array. If ``copy=False`` (default), this is a sliced
+        view of the input array.
+    """
+    ar = np.array(ar, copy=False)
+
+    if isinstance(crop_width, Integral):
+        crops = [[crop_width, crop_width]] * ar.ndim
+    elif isinstance(crop_width[0], Integral):
+        if len(crop_width) == 1:
+            crops = [[crop_width[0], crop_width[0]]] * ar.ndim
+        elif len(crop_width) == 2:
+            crops = [crop_width] * ar.ndim
+        else:
+            raise ValueError(
+                f'crop_width has an invalid length: {len(crop_width)}\n'
+                f'crop_width should be a sequence of N pairs, '
+                f'a single pair, or a single integer'
+            )
+    elif len(crop_width) == 1:
+        crops = [crop_width[0]] * ar.ndim
+    elif len(crop_width) == ar.ndim:
+        crops = crop_width
+    else:
+        raise ValueError(
+            f'crop_width has an invalid length: {len(crop_width)}\n'
+            f'crop_width should be a sequence of N pairs, '
+            f'a single pair, or a single integer'
+        )
+
+    slices = tuple(slice(a, ar.shape[i] - b) for i, (a, b) in enumerate(crops))
+    if copy:
+        cropped = np.array(ar[slices], order=order, copy=True)
+    else:
+        cropped = ar[slices]
+    return cropped

vlmpy310/lib/python3.10/site-packages/skimage/util/compare.py

@@ -0,0 +1,132 @@
+import functools
+import warnings
+from itertools import product
+
+import numpy as np
+
+from .dtype import img_as_float
+
+
+def _rename_image_params(func):
+    wm_images = (
+        "Since version 0.24, the two input images are named `image0` and "
+        "`image1` (instead of `image1` and `image2`, respectively). Please use "
+        "`image0, image1` to avoid this warning for now, and avoid an error "
+        "from version 0.26 onwards."
+    )
+
+    wm_method = (
+        "Starting in version 0.24, all arguments following `image0, image1` "
+        "(including `method`) will be keyword-only. Please pass `method=` "
+        "in the function call to avoid this warning for now, and avoid an error "
+        "from version 0.26 onwards."
+    )
+
+    @functools.wraps(func)
+    def wrapper(*args, **kwargs):
+        # Turn all args into kwargs
+        for i, (value, param) in enumerate(
+            zip(args, ["image0", "image1", "method", "n_tiles"])
+        ):
+            if i >= 2:
+                warnings.warn(wm_method, category=FutureWarning, stacklevel=2)
+            if param in kwargs:
+                raise ValueError(
+                    f"{param} passed both as positional and keyword argument."
+                )
+            else:
+                kwargs[param] = value
+        args = tuple()
+
+        # Account for `image2` if given
+        if "image2" in kwargs.keys():
+            warnings.warn(wm_images, category=FutureWarning, stacklevel=2)
+
+            # Safely move `image2` to `image1` if that's empty
+            if "image1" in kwargs.keys():
+                # Safely move `image1` to `image0`
+                if "image0" in kwargs.keys():
+                    raise ValueError(
+                        "Three input images given; please use only `image0` "
+                        "and `image1`."
+                    )
+                kwargs["image0"] = kwargs.pop("image1")
+            kwargs["image1"] = kwargs.pop("image2")
+
+        return func(*args, **kwargs)
+
+    return wrapper
+
+
+@_rename_image_params
+def compare_images(image0, image1, *, method='diff', n_tiles=(8, 8)):
+    """
+    Return an image showing the differences between two images.
+
+    .. versionadded:: 0.16
+
+    Parameters
+    ----------
+    image0, image1 : ndarray, shape (M, N)
+        Images to process, must be of the same shape.
+
+        .. versionchanged:: 0.24
+            `image1` and `image2` were renamed into `image0` and `image1`
+            respectively.
+    method : string, optional
+        Method used for the comparison.
+        Valid values are {'diff', 'blend', 'checkerboard'}.
+        Details are provided in the note section.
+
+        .. versionchanged:: 0.24
+            This parameter and following ones are keyword-only.
+    n_tiles : tuple, optional
+        Used only for the `checkerboard` method. Specifies the number
+        of tiles (row, column) to divide the image.
+
+    Returns
+    -------
+    comparison : ndarray, shape (M, N)
+        Image showing the differences.
+
+    Notes
+    -----
+    ``'diff'`` computes the absolute difference between the two images.
+    ``'blend'`` computes the mean value.
+    ``'checkerboard'`` makes tiles of dimension `n_tiles` that display
+    alternatively the first and the second image. Note that images must be
+    2-dimensional to be compared with the checkerboard method.
+    """
+
+    if image1.shape != image0.shape:
+        raise ValueError('Images must have the same shape.')
+
+    img1 = img_as_float(image0)
+    img2 = img_as_float(image1)
+
+    if method == 'diff':
+        comparison = np.abs(img2 - img1)
+    elif method == 'blend':
+        comparison = 0.5 * (img2 + img1)
+    elif method == 'checkerboard':
+        if img1.ndim != 2:
+            raise ValueError(
+                'Images must be 2-dimensional to be compared with the '
+                'checkerboard method.'
+            )
+        shapex, shapey = img1.shape
+        mask = np.full((shapex, shapey), False)
+        stepx = int(shapex / n_tiles[0])
+        stepy = int(shapey / n_tiles[1])
+        for i, j in product(range(n_tiles[0]), range(n_tiles[1])):
+            if (i + j) % 2 == 0:
+                mask[i * stepx : (i + 1) * stepx, j * stepy : (j + 1) * stepy] = True
+        comparison = np.zeros_like(img1)
+        comparison[mask] = img1[mask]
+        comparison[~mask] = img2[~mask]
+    else:
+        raise ValueError(
+            'Wrong value for `method`. '
+            'Must be either "diff", "blend" or "checkerboard".'
+        )
+    return comparison

vlmpy310/lib/python3.10/site-packages/skimage/util/dtype.py

@@ -0,0 +1,600 @@
+import warnings
+from warnings import warn
+
+import numpy as np
+
+
+__all__ = [
+    'img_as_float32',
+    'img_as_float64',
+    'img_as_float',
+    'img_as_int',
+    'img_as_uint',
+    'img_as_ubyte',
+    'img_as_bool',
+    'dtype_limits',
+]
+
+# Some of these may or may not be aliases depending on architecture & platform
+_integer_types = (
+    np.int8,
+    np.byte,
+    np.int16,
+    np.short,
+    np.int32,
+    np.int64,
+    np.longlong,
+    np.int_,
+    np.intp,
+    np.intc,
+    int,
+    np.uint8,
+    np.ubyte,
+    np.uint16,
+    np.ushort,
+    np.uint32,
+    np.uint64,
+    np.ulonglong,
+    np.uint,
+    np.uintp,
+    np.uintc,
+)
+_integer_ranges = {t: (np.iinfo(t).min, np.iinfo(t).max) for t in _integer_types}
+dtype_range = {
+    bool: (False, True),
+    np.bool_: (False, True),
+    float: (-1, 1),
+    np.float16: (-1, 1),
+    np.float32: (-1, 1),
+    np.float64: (-1, 1),
+}
+
+with warnings.catch_warnings():
+    warnings.filterwarnings('ignore', category=DeprecationWarning)
+
+    # np.bool8 is a deprecated alias of np.bool_
+    if hasattr(np, 'bool8'):
+        dtype_range[np.bool8] = (False, True)
+
+dtype_range.update(_integer_ranges)
+
+_supported_types = list(dtype_range.keys())
+
+
+def dtype_limits(image, clip_negative=False):
+    """Return intensity limits, i.e. (min, max) tuple, of the image's dtype.
+
+    Parameters
+    ----------
+    image : ndarray
+        Input image.
+    clip_negative : bool, optional
+        If True, clip the negative range (i.e. return 0 for min intensity)
+        even if the image dtype allows negative values.
+
+    Returns
+    -------
+    imin, imax : tuple
+        Lower and upper intensity limits.
+    """
+    imin, imax = dtype_range[image.dtype.type]
+    if clip_negative:
+        imin = 0
+    return imin, imax
+
+
+def _dtype_itemsize(itemsize, *dtypes):
+    """Return first of `dtypes` with itemsize greater than `itemsize`
+
+    Parameters
+    ----------
+    itemsize: int
+        The data type object element size.
+
+    Other Parameters
+    ----------------
+    *dtypes:
+        Any Object accepted by `np.dtype` to be converted to a data
+        type object
+
+    Returns
+    -------
+    dtype: data type object
+        First of `dtypes` with itemsize greater than `itemsize`.
+
+    """
+    return next(dt for dt in dtypes if np.dtype(dt).itemsize >= itemsize)
+
+
+def _dtype_bits(kind, bits, itemsize=1):
+    """Return dtype of `kind` that can store a `bits` wide unsigned int
+
+    Parameters:
+    kind: str
+        Data type kind.
+    bits: int
+        Desired number of bits.
+    itemsize: int
+        The data type object element size.
+
+    Returns
+    -------
+    dtype: data type object
+        Data type of `kind` that can store a `bits` wide unsigned int
+
+    """
+
+    s = next(
+        i
+        for i in (itemsize,) + (2, 4, 8)
+        if bits < (i * 8) or (bits == (i * 8) and kind == 'u')
+    )
+
+    return np.dtype(kind + str(s))
+
+
+def _scale(a, n, m, copy=True):
+    """Scale an array of unsigned/positive integers from `n` to `m` bits.
+
+    Numbers can be represented exactly only if `m` is a multiple of `n`.
+
+    Parameters
+    ----------
+    a : ndarray
+        Input image array.
+    n : int
+        Number of bits currently used to encode the values in `a`.
+    m : int
+        Desired number of bits to encode the values in `out`.
+    copy : bool, optional
+        If True, allocates and returns new array. Otherwise, modifies
+        `a` in place.
+
+    Returns
+    -------
+    out : array
+        Output image array. Has the same kind as `a`.
+    """
+    kind = a.dtype.kind
+    if n > m and a.max() < 2**m:
+        mnew = int(np.ceil(m / 2) * 2)
+        if mnew > m:
+            dtype = f'int{mnew}'
+        else:
+            dtype = f'uint{mnew}'
+        n = int(np.ceil(n / 2) * 2)
+        warn(
+            f'Downcasting {a.dtype} to {dtype} without scaling because max '
+            f'value {a.max()} fits in {dtype}',
+            stacklevel=3,
+        )
+        return a.astype(_dtype_bits(kind, m))
+    elif n == m:
+        return a.copy() if copy else a
+    elif n > m:
+        # downscale with precision loss
+        if copy:
+            b = np.empty(a.shape, _dtype_bits(kind, m))
+            np.floor_divide(a, 2 ** (n - m), out=b, dtype=a.dtype, casting='unsafe')
+            return b
+        else:
+            a //= 2 ** (n - m)
+            return a
+    elif m % n == 0:
+        # exact upscale to a multiple of `n` bits
+        if copy:
+            b = np.empty(a.shape, _dtype_bits(kind, m))
+            np.multiply(a, (2**m - 1) // (2**n - 1), out=b, dtype=b.dtype)
+            return b
+        else:
+            a = a.astype(_dtype_bits(kind, m, a.dtype.itemsize), copy=False)
+            a *= (2**m - 1) // (2**n - 1)
+            return a
+    else:
+        # upscale to a multiple of `n` bits,
+        # then downscale with precision loss
+        o = (m // n + 1) * n
+        if copy:
+            b = np.empty(a.shape, _dtype_bits(kind, o))
+            np.multiply(a, (2**o - 1) // (2**n - 1), out=b, dtype=b.dtype)
+            b //= 2 ** (o - m)
+            return b
+        else:
+            a = a.astype(_dtype_bits(kind, o, a.dtype.itemsize), copy=False)
+            a *= (2**o - 1) // (2**n - 1)
+            a //= 2 ** (o - m)
+            return a
+
+
+def _convert(image, dtype, force_copy=False, uniform=False):
+    """
+    Convert an image to the requested data-type.
+
+    Warnings are issued in case of precision loss, or when negative values
+    are clipped during conversion to unsigned integer types (sign loss).
+
+    Floating point values are expected to be normalized and will be clipped
+    to the range [0.0, 1.0] or [-1.0, 1.0] when converting to unsigned or
+    signed integers respectively.
+
+    Numbers are not shifted to the negative side when converting from
+    unsigned to signed integer types. Negative values will be clipped when
+    converting to unsigned integers.
+
+    Parameters
+    ----------
+    image : ndarray
+        Input image.
+    dtype : dtype
+        Target data-type.
+    force_copy : bool, optional
+        Force a copy of the data, irrespective of its current dtype.
+    uniform : bool, optional
+        Uniformly quantize the floating point range to the integer range.
+        By default (uniform=False) floating point values are scaled and
+        rounded to the nearest integers, which minimizes back and forth
+        conversion errors.
+
+    .. versionchanged:: 0.15
+        ``_convert`` no longer warns about possible precision or sign
+        information loss. See discussions on these warnings at:
+        https://github.com/scikit-image/scikit-image/issues/2602
+        https://github.com/scikit-image/scikit-image/issues/543#issuecomment-208202228
+        https://github.com/scikit-image/scikit-image/pull/3575
+
+    References
+    ----------
+    .. [1] DirectX data conversion rules.
+           https://msdn.microsoft.com/en-us/library/windows/desktop/dd607323%28v=vs.85%29.aspx
+    .. [2] Data Conversions. In "OpenGL ES 2.0 Specification v2.0.25",
+           pp 7-8. Khronos Group, 2010.
+    .. [3] Proper treatment of pixels as integers. A.W. Paeth.
+           In "Graphics Gems I", pp 249-256. Morgan Kaufmann, 1990.
+    .. [4] Dirty Pixels. J. Blinn. In "Jim Blinn's corner: Dirty Pixels",
+           pp 47-57. Morgan Kaufmann, 1998.
+
+    """
+    image = np.asarray(image)
+    dtypeobj_in = image.dtype
+    if dtype is np.floating:
+        dtypeobj_out = np.dtype('float64')
+    else:
+        dtypeobj_out = np.dtype(dtype)
+    dtype_in = dtypeobj_in.type
+    dtype_out = dtypeobj_out.type
+    kind_in = dtypeobj_in.kind
+    kind_out = dtypeobj_out.kind
+    itemsize_in = dtypeobj_in.itemsize
+    itemsize_out = dtypeobj_out.itemsize
+
+    # Below, we do an `issubdtype` check.  Its purpose is to find out
+    # whether we can get away without doing any image conversion.  This happens
+    # when:
+    #
+    # - the output and input dtypes are the same or
+    # - when the output is specified as a type, and the input dtype
+    #   is a subclass of that type (e.g. `np.floating` will allow
+    #   `float32` and `float64` arrays through)
+
+    if np.issubdtype(dtype_in, dtype):
+        if force_copy:
+            image = image.copy()
+        return image
+
+    if not (dtype_in in _supported_types and dtype_out in _supported_types):
+        raise ValueError(f'Cannot convert from {dtypeobj_in} to ' f'{dtypeobj_out}.')
+
+    if kind_in in 'ui':
+        imin_in = np.iinfo(dtype_in).min
+        imax_in = np.iinfo(dtype_in).max
+    if kind_out in 'ui':
+        imin_out = np.iinfo(dtype_out).min
+        imax_out = np.iinfo(dtype_out).max
+
+    # any -> binary
+    if kind_out == 'b':
+        return image > dtype_in(dtype_range[dtype_in][1] / 2)
+
+    # binary -> any
+    if kind_in == 'b':
+        result = image.astype(dtype_out)
+        if kind_out != 'f':
+            result *= dtype_out(dtype_range[dtype_out][1])
+        return result
+
+    # float -> any
+    if kind_in == 'f':
+        if kind_out == 'f':
+            # float -> float
+            return image.astype(dtype_out)
+
+        if np.min(image) < -1.0 or np.max(image) > 1.0:
+            raise ValueError("Images of type float must be between -1 and 1.")
+        # floating point -> integer
+        # use float type that can represent output integer type
+        computation_type = _dtype_itemsize(
+            itemsize_out, dtype_in, np.float32, np.float64
+        )
+
+        if not uniform:
+            if kind_out == 'u':
+                image_out = np.multiply(image, imax_out, dtype=computation_type)
+            else:
+                image_out = np.multiply(
+                    image, (imax_out - imin_out) / 2, dtype=computation_type
+                )
+                image_out -= 1.0 / 2.0
+            np.rint(image_out, out=image_out)
+            np.clip(image_out, imin_out, imax_out, out=image_out)
+        elif kind_out == 'u':
+            image_out = np.multiply(image, imax_out + 1, dtype=computation_type)
+            np.clip(image_out, 0, imax_out, out=image_out)
+        else:
+            image_out = np.multiply(
+                image, (imax_out - imin_out + 1.0) / 2.0, dtype=computation_type
+            )
+            np.floor(image_out, out=image_out)
+            np.clip(image_out, imin_out, imax_out, out=image_out)
+        return image_out.astype(dtype_out)
+
+    # signed/unsigned int -> float
+    if kind_out == 'f':
+        # use float type that can exactly represent input integers
+        computation_type = _dtype_itemsize(
+            itemsize_in, dtype_out, np.float32, np.float64
+        )
+
+        if kind_in == 'u':
+            # using np.divide or np.multiply doesn't copy the data
+            # until the computation time
+            image = np.multiply(image, 1.0 / imax_in, dtype=computation_type)
+            # DirectX uses this conversion also for signed ints
+            # if imin_in:
+            #     np.maximum(image, -1.0, out=image)
+        elif kind_in == 'i':
+            # From DirectX conversions:
+            # The most negative value maps to -1.0f
+            # Every other value is converted to a float (call it c)
+            # and then result = c * (1.0f / (2⁽ⁿ⁻¹⁾-1)).
+
+            image = np.multiply(image, 1.0 / imax_in, dtype=computation_type)
+            np.maximum(image, -1.0, out=image)
+
+        else:
+            image = np.add(image, 0.5, dtype=computation_type)
+            image *= 2 / (imax_in - imin_in)
+
+        return np.asarray(image, dtype_out)
+
+    # unsigned int -> signed/unsigned int
+    if kind_in == 'u':
+        if kind_out == 'i':
+            # unsigned int -> signed int
+            image = _scale(image, 8 * itemsize_in, 8 * itemsize_out - 1)
+            return image.view(dtype_out)
+        else:
+            # unsigned int -> unsigned int
+            return _scale(image, 8 * itemsize_in, 8 * itemsize_out)
+
+    # signed int -> unsigned int
+    if kind_out == 'u':
+        image = _scale(image, 8 * itemsize_in - 1, 8 * itemsize_out)
+        result = np.empty(image.shape, dtype_out)
+        np.maximum(image, 0, out=result, dtype=image.dtype, casting='unsafe')
+        return result
+
+    # signed int -> signed int
+    if itemsize_in > itemsize_out:
+        return _scale(image, 8 * itemsize_in - 1, 8 * itemsize_out - 1)
+
+    image = image.astype(_dtype_bits('i', itemsize_out * 8))
+    image -= imin_in
+    image = _scale(image, 8 * itemsize_in, 8 * itemsize_out, copy=False)
+    image += imin_out
+    return image.astype(dtype_out)
+
+
+def convert(image, dtype, force_copy=False, uniform=False):
+    warn(
+        "The use of this function is discouraged as its behavior may change "
+        "dramatically in scikit-image 1.0. This function will be removed "
+        "in scikit-image 1.0.",
+        FutureWarning,
+        stacklevel=2,
+    )
+    return _convert(image=image, dtype=dtype, force_copy=force_copy, uniform=uniform)
+
+
+if _convert.__doc__ is not None:
+    convert.__doc__ = (
+        _convert.__doc__
+        + """
+
+    Warns
+    -----
+    FutureWarning:
+        .. versionadded:: 0.17
+
+        The use of this function is discouraged as its behavior may change
+        dramatically in scikit-image 1.0. This function will be removed
+        in scikit-image 1.0.
+    """
+    )
+
+
+def img_as_float32(image, force_copy=False):
+    """Convert an image to single-precision (32-bit) floating point format.
+
+    Parameters
+    ----------
+    image : ndarray
+        Input image.
+    force_copy : bool, optional
+        Force a copy of the data, irrespective of its current dtype.
+
+    Returns
+    -------
+    out : ndarray of float32
+        Output image.
+
+    Notes
+    -----
+    The range of a floating point image is [0.0, 1.0] or [-1.0, 1.0] when
+    converting from unsigned or signed datatypes, respectively.
+    If the input image has a float type, intensity values are not modified
+    and can be outside the ranges [0.0, 1.0] or [-1.0, 1.0].
+
+    """
+    return _convert(image, np.float32, force_copy)
+
+
+def img_as_float64(image, force_copy=False):
+    """Convert an image to double-precision (64-bit) floating point format.
+
+    Parameters
+    ----------
+    image : ndarray
+        Input image.
+    force_copy : bool, optional
+        Force a copy of the data, irrespective of its current dtype.
+
+    Returns
+    -------
+    out : ndarray of float64
+        Output image.
+
+    Notes
+    -----
+    The range of a floating point image is [0.0, 1.0] or [-1.0, 1.0] when
+    converting from unsigned or signed datatypes, respectively.
+    If the input image has a float type, intensity values are not modified
+    and can be outside the ranges [0.0, 1.0] or [-1.0, 1.0].
+
+    """
+    return _convert(image, np.float64, force_copy)
+
+
+def img_as_float(image, force_copy=False):
+    """Convert an image to floating point format.
+
+    This function is similar to `img_as_float64`, but will not convert
+    lower-precision floating point arrays to `float64`.
+
+    Parameters
+    ----------
+    image : ndarray
+        Input image.
+    force_copy : bool, optional
+        Force a copy of the data, irrespective of its current dtype.
+
+    Returns
+    -------
+    out : ndarray of float
+        Output image.
+
+    Notes
+    -----
+    The range of a floating point image is [0.0, 1.0] or [-1.0, 1.0] when
+    converting from unsigned or signed datatypes, respectively.
+    If the input image has a float type, intensity values are not modified
+    and can be outside the ranges [0.0, 1.0] or [-1.0, 1.0].
+
+    """
+    return _convert(image, np.floating, force_copy)
+
+
+def img_as_uint(image, force_copy=False):
+    """Convert an image to 16-bit unsigned integer format.
+
+    Parameters
+    ----------
+    image : ndarray
+        Input image.
+    force_copy : bool, optional
+        Force a copy of the data, irrespective of its current dtype.
+
+    Returns
+    -------
+    out : ndarray of uint16
+        Output image.
+
+    Notes
+    -----
+    Negative input values will be clipped.
+    Positive values are scaled between 0 and 65535.
+
+    """
+    return _convert(image, np.uint16, force_copy)
+
+
+def img_as_int(image, force_copy=False):
+    """Convert an image to 16-bit signed integer format.
+
+    Parameters
+    ----------
+    image : ndarray
+        Input image.
+    force_copy : bool, optional
+        Force a copy of the data, irrespective of its current dtype.
+
+    Returns
+    -------
+    out : ndarray of int16
+        Output image.
+
+    Notes
+    -----
+    The values are scaled between -32768 and 32767.
+    If the input data-type is positive-only (e.g., uint8), then
+    the output image will still only have positive values.
+
+    """
+    return _convert(image, np.int16, force_copy)
+
+
+def img_as_ubyte(image, force_copy=False):
+    """Convert an image to 8-bit unsigned integer format.
+
+    Parameters
+    ----------
+    image : ndarray
+        Input image.
+    force_copy : bool, optional
+        Force a copy of the data, irrespective of its current dtype.
+
+    Returns
+    -------
+    out : ndarray of ubyte (uint8)
+        Output image.
+
+    Notes
+    -----
+    Negative input values will be clipped.
+    Positive values are scaled between 0 and 255.
+
+    """
+    return _convert(image, np.uint8, force_copy)
+
+
+def img_as_bool(image, force_copy=False):
+    """Convert an image to boolean format.
+
+    Parameters
+    ----------
+    image : ndarray
+        Input image.
+    force_copy : bool, optional
+        Force a copy of the data, irrespective of its current dtype.
+
+    Returns
+    -------
+    out : ndarray of bool (`bool_`)
+        Output image.
+
+    Notes
+    -----
+    The upper half of the input dtype's positive range is True, and the lower
+    half is False. All negative values (if present) are False.
+
+    """
+    return _convert(image, bool, force_copy)

vlmpy310/lib/python3.10/site-packages/skimage/util/lookfor.py

@@ -0,0 +1,30 @@
+import sys
+
+from .._vendored.numpy_lookfor import lookfor as _lookfor
+
+
+def lookfor(what):
+    """Do a keyword search on scikit-image docstrings and print results.
+
+    .. warning::
+
+        This function may also print results that are not part of
+        scikit-image's public API.
+
+    Parameters
+    ----------
+    what : str
+        Words to look for.
+
+    Examples
+    --------
+    >>> import skimage as ski
+    >>> ski.util.lookfor('regular_grid')
+    Search results for 'regular_grid'
+    ---------------------------------
+    skimage.util.regular_grid
+        Find `n_points` regularly spaced along `ar_shape`.
+    skimage.util.lookfor
+        Do a keyword search on scikit-image docstrings and print results.
+    """
+    return _lookfor(what, sys.modules[__name__.split('.')[0]])