Py之slidingwindow&sliding_window：slidingwindow、sliding_window的简介、安装、使用方法之详细攻略

 

目录

sliding_window的简介

sliding_window的安装

sliding_window的使用方法

 

 

slidingwindow、sliding_window的简介

 

sliding_window

参考文章：http://stackoverflow.com/a/6822761

 

slidingwindow

       这是一个简单的小Python库，用于将一组窗口计算成一个较大的数据集，设计用于图像处理算法，该算法使用滑动窗口将处理分解为一系列较小的块。此外，还可以指定一组可选转换，以应用于每个窗口。

       还包括用于计算窗口距离矩阵的功能，用于需要考虑窗口中每个像素（相对于其中心）的位置的用例，以及用于批处理窗口和合并应用于窗口的处理结果的功能。

       对于在生成窗口边界后需要修改它们的用例，可以将窗口对象转换为（x，y，w，h）元组表示的矩形。还提供了转换矩形的功能（填充、裁剪、强制方形宽高比等）。

       还提供了创建NumPy数组的功能，如果可用的系统内存不足，该功能将回退到使用内存映射临时文件作为下划线数组缓冲区，以及确定生成窗口时可以使用的最大方形窗口大小。

 

 

 

 

sliding_window的安装

pip install sliding_window



pip install slidingwindow



 

 

sliding_window的使用方法

更新……

import slidingwindow as sw
import numpy as np

# Load our input image here
# data = load(...)

# Generate the set of windows, with a 256-pixel max window size and 50% overlap
windows = sw.generate(data, sw.DimOrder.HeightWidthChannel, 256, 0.5)

# Do stuff with the generated windows
for window in windows:
	subset = data[ window.indices() ]
	# ...

# Or, using some transformation functions
tranforms = [
	lambda m: np.fliplr(m),
	lambda m: np.flipud(m),
	lambda m: np.rot90(m, k=1, axes=(0, 1)),
	lambda m: np.rot90(m, k=3, axes=(0, 1))
]
windows = sw.generate(data, sw.DimOrder.HeightWidthChannel, 256, 0.5, tranforms)
for window in windows:
	transformed = window.apply(data)
	# ...

# Alternatively, if we want to modify each window
windows = sw.generate(data, sw.DimOrder.HeightWidthChannel, 256, 0.5)
for window in windows:
	rect = window.getRect()
	transformed = sw.padRectEqually(rect, 100, data.shape)
	window.setRect(transformed)
	# ...


 

 

 

 

 

 

 

 

 

 

 

 

 

 

leetcode 239.Sliding Window Maximum
You are given an array of integers nums, there is a sliding window of size k which is moving from the very left of the array to the very right. You can only see the k numbers in the window. Each time the sliding window moves right by one position.
Return the max sliding window.



Example 1:

Input: nums = [1,3,-1,-3,5,3,6,7], k = 3

Output: [3,3,5,5,6,7]

Example 2:

Input: nums = [1], k = 1

Output: [1]

Example 3:

Input: nums = [1,-1], k = 1

Output: [1,-1]

Example 4:

Input: nums = [9,11], k = 2

Output: [11]

Example 5:

Input: nums = [4,-2], k = 2

Output: [4]

Constraints:

1 <= nums.length <= 105

-104 <= nums[i] <= 104

1 <= k <= nums.length
来源：力扣（LeetCode）

链接：https://leetcode-cn.com/problems/sliding-window-maximum


这题可以用双端单调队列来解决这道题：

因为在窗口向前滑动的过程中，我们会发现，每次窗口向前滑动的时候，要添加一个数的同时还要减少一个数，添加一个新的元素进去，如果这个新的元素比窗口内的一些数要大，那么这些比新元素要小的数，直到被淘汰都没有机会露个面。

eg: 序列 [10，7，5]，6，4，3

在窗口向前滑动后，新数据6比5要大，那么，这个5直到被淘汰都不可能是最大的数，因为有个6一直打压 着它。

10，[7，5，6]，4，3   ----------------------    Max = 7

10，7，[5，6，4]，3   ----------------------    Max = 6

10，7，5，[6，4，3]   ----------------------    Max = 6
那么我们可以在遍历一遍序列时，在压入一个新数据的时候，将之前比它小的所有数字，全都删除，只保留比它大的数字，那么最终得到的序列一定是个单调递减的序列，这就是单调队列。

那为什么要双端队列呢，因为在添加新数据进入队列，以及删除比新数据要小的数据都是在队尾实现，但要获得每次移动窗口后最大的数据的值，就得要队头元素，用queue.front()来获取，而且窗口向前滑动，得删除掉滑动窗口左端的元素，所以得用双端单调队列。



代码：
class Solution {
private:
    deque<int> data; //double-ended queue
public:
    void push(int DATA)
    {
        //在队尾添加元素，把前面比新元素小的元素都删除掉
        while(!data.empty() && data.back() < DATA){
            data.pop_back();
        }
        data.push_back(DATA);
    } //形成单调递减序列

    int max(){ return data.front(); }

    void pop(int DATA){
        /*滑动窗口向前移动一位，右边加一位，左边得减一位，但如果已经被压扁了，
        也就是说队列里面已经不存在最左边的那个数，就不用删除，否则就得删除掉这个数*/
        if(!data.empty() && data.front() == DATA){
            data.pop_front();
        }
    };

    vector<int> maxSlidingWindow(vector<int>& nums, int k) {
        Solution window;
        vector<int> res;
        for(int i = 0; i < nums.size(); i++){
            if(i < k - 1){ //先填满窗口的前K - 1
                window.push(nums[i]);
            }
            else{ //窗口向前滑动
                window.push(nums[i]);
                res.push_back(window.max());
                window.pop(nums[i - k + 1]); //指滑动窗口最左边的数字，查看它是否在队列中，有则删除掉
            }
        }
        return res;
    }
};


洛谷P1886 滑动窗口 /【模板】单调队列
洛谷同样有这道题，只是多了个求最小值。思路是一样的。


输入 #1

8 3

1 3 -1 -3 5 3 6 7

输出 #1

-1 -3 -3 -3 3 3

3 3 5 5 6 7

链接：https://www.luogu.com.cn/problem/P1886
#include<iostream>
#include<deque>
#include<cstdio>
#include<vector>
using namespace std;
long long int res[1000001] = { 0 }, res1[1000001] = { 0 };
void push(deque<long long int>& line, long long int data, int flag)
{
	if (flag == 1){
		while (!line.empty() && line.back() < data)
			line.pop_back();
		line.push_back(data);
	}
	else{
		while (!line.empty() && line.back() > data)
			line.pop_back();
		line.push_back(data);
	}
}

void pop_data(deque<long long int>& line, long long int data)
{
	if (!line.empty() && line.front() == data)
		line.pop_front();
}

int main(){
	deque<long long int> q, qq;
	int i, n, k, len1 = 0, len2 = 0;
	long long int xx;
	vector<long long int> nums;
	cin >> n >> k;
	for (i = 0; i<n; i++){
		cin >> xx;
		nums.push_back(xx);
	}
	for (i = 0; i < n; i++){
		if (i < k - 1){
			push(q, nums[i], 1);
			push(qq, nums[i], 2);
		}
		else{
			push(q, nums[i], 1);
			push(qq, nums[i], 2);
			res[len1++] = q.front();
			res1[len2++] = qq.front();
			pop_data(q, nums[i - k + 1]);
			pop_data(qq, nums[i - k + 1]);
		}
	}
	for (i = 0; i<len2; i++)
		printf("%lld ", res1[i]);
	printf("\n");
	for (i = 0; i<len1; i++)
		printf("%lld ", res[i]);
	return 0;
}

sliding-panel

项目地址：PierfrancescoSoffritti/sliding-panel 

简介：Android sliding panel that is part of the view hierarchy, not above it.

更多：作者   提 Bug   

标签：

 



 



A ViewGroup that implements a sliding panel that is part of the view hierarchy, not above it.

Difference from other libraries

All other implementations of the bottom sheet pattern and sliding panel patternimplement a panel that sits above all the other Views of the app. When the panel is collapsed (but visible) the only way to set its position is by using a peek factor (its distance from the bottom of the screen).

With this library the sliding panel is placed exactly where it is supposed to be in the view hierarchy, just like it would be in a vertical (or horizontal) LinearLayout. It doesn't sit above other Views.

Overview

SlidingPanel is a ViewGroup exending FrameLayout.

It has exacly two children: a non sliding view and a sliding view.

The non sliding view is just a view that doesn't move, positioned as if SlidingPanel was a LinearLayout.
	
The sliding view is a View that can be dragged by the user. It slides over the non sliding view, both vertically and horizontally.
The sliding view can be collapsed or expanded.

When collapsed, the sliding view is exactly where it would be if SlidingPanel was a LinearLayout.
	
When expanded, the sliding view is positioned to exactly cover the non sliding view. (Therefore the maximum amount of movement allowed to the sliding view is equal to the height (or width) of the non sliding view)