semvec/pypi-packages huggingface dataset:
RECLAC 1.0.0
A package to compute recurrence lacunarity and other box-counting-based recurrence quantifiers

RECLAC Python
==============

The RECLAC Python package provides functions to compute **recurrence lacunarity** as described in [[braun2021] (Open Source)](https://link.springer.com/article/10.1007/s11071-021-06457-5#article-info). Its functionality is very basic at the current stage and will probably be extended in the near future. It also offers a basic implementation for the computation of recurrence plots and the box-counting dimension.


<img src="https://github.com/ToBraun/RECLAC/blob/main/icon.png" alt="drawing" width="750"/>

Getting started
===============

Install from [PyPi](https://pypi.org/project/RECLAC/) by simply typing

`pip install RECLAC` 

in your console.

Requirements
====

numpy >= 1.21\
scipy >= 1.2.1



Documentation
=============

I am currently working on a comprehensive documentation.


Citing and reference
====================
If you would like to use the provided tools in your research, please cite


> Braun, T., Unni, V.R., Sujith, R.I. et al. Detection of dynamical regime transitions with lacunarity as a multiscale recurrence quantification measure. Nonlinear Dyn 104, 3955–3973 (2021). [https://doi.org/10.1007/s11071-021-06457-5](https://link.springer.com/article/10.1007/s11071-021-06457-5)




or as BiBTeX-entry:



>@article{braun2021detection,\
title={Detection of dynamical regime transitions with lacunarity as a multiscale recurrence quantification measure},\
author={Braun, Tobias and Unni, Vishnu R and Sujith, RI and Kurths, Juergen and Marwan, Norbert},\
journal={Nonlinear Dynamics},\
pages={1--19},\
year={2021},\
publisher={Springer}\



Licence
=======
This is program is free software and runs under [MIT Licence](https://opensource.org/licenses/MIT).
segment-image 0.0.3
A package used to segment an image
Requires Python: >=3.6

# segment_image

### Abstract

- A lib can be used to segment image https://pypi.org/project/segment-image/
- The first version just has k_means algorithm.

### install

- python >= 3.6
- install
```
$ pip install segment-image
```


### how to use 

- `cv2`need to be installed by
`
pip install opencv-python
`

- Kmeans
```
import segment_image
import cv2

img = cv2.imread("./sample_imgs/lena.png")
k = 2 # number of segments
k_means = segment_image.Kmeans(img, k)
iteration = 10
convergence_radius = 1e-6
k_means.run(iteration, convergence_radius)

```

- gvf_snake (The speed is so slow, so I use small `max_iteration_gvf` and `max_iteration_gvf`. if you want to get great results, pleas adjust them)
```
import segment_image
import cv2

img = cv2.imread("./sample_imgs/star.png")
max_iteration_gvf = 10
max_iteration_snake = 10
gvf_snake = segment_image.GVFSnake(img, max_iteration_gvf, max_iteration_snake)
gvf_snake.run(save=True)

```

### example

- https://github.com/MyDuan/segment_image/blob/main/examples/example_of_kmeans.py
- https://github.com/MyDuan/segment_image/blob/main/examples/example_of_gvf_snake.py
- results:
    - kmeans:

    ![kmeans_re](https://user-images.githubusercontent.com/19246998/113019886-04c81500-91bd-11eb-8075-016c64f5161b.png)

    - gvf_snake
    <img width="300" alt="star_re" src="https://user-images.githubusercontent.com/19246998/135444069-82e60a2d-7f99-4266-990e-5c4e99ccf76b.png">
pytorch-pyramid-pooling 0.1.0
A PyTorch implementation of Spatial and Temporal Pyramid Pooling
Requires Python: >=3.6

# Pyramid Pooling implemented in PyTorch
This Module implements Spatial Pyramid Pooling (SPP) and Temporal Pyramid Pooling (TPP) as described in different papers.

**NOTE** This repo has been forked from <a href="https://github.com/revidee/pytorch-pyramid-pooling">Revidee's original</a> (which seems to no longer be under maintenance) to publish on Pypi. I (Eric Musa) take no credit for writing the Pyramid Pooling code, but could not find any information on Revidee to provide proper credit.

# The purpose of this fork is to continue maintenance of this package and post on Pypi


![SPP-TPP Comparison](https://github.com/eric-musa/pytorch-pyramid-pooling/blob/master/comparison-spp-tpp.png "SPP-TPP Comparison")


Temporal Pyramid Pooling:
------
[Sudholt, Fink: Evaluating Word String Embeddings and LossFunctions for CNN-based Word Spotting](http://patrec.cs.tu-dortmund.de/pubs/papers/Sudholt2017-EWS.pdf "Sudholt, Fink: Evaluating Word String Embeddings and LossFunctions for CNN-based Word Spotting")

### Principle
Given an 2D input Tensor, Temporal Pyramid Pooling divides the input in **x** _stripes_ which **extend through the height** of the image and **width of roughly (input_width / x)**. These stripes are then each pooled with max- or avg-pooling to calculate the output.

### Animated Principle
![TPP Visualization](https://github.com/eric-musa/pytorch-pyramid-pooling/blob/master/pytorch-tpp-visual.gif "TPP Visualization")

Spatial Pyramid Pooling:
------
[He, et. al.: Spatial Pyramid Pooling in Deep Convolutional Networks for Visual Recognition](https://arxiv.org/abs/1406.4729 "He et. al.: Spatial Pyramid Pooling in Deep Convolutional Networks for Visual Recognition")

### Principle
Given an 2D input Tensor, Spatial Pyramid Pooling divides the input in **x²** _rectangles_ with **height of roughly (input_height / x)** and **width of roughly (input_width / x)**. These rectangles are then each pooled with max- or avg-pooling to calculate the output.