图片旋转匹配练习

参考文章：https://blog.csdn.net/qq_43735106/article/details/106734397
https://blog.csdn.net/weixin_43594279/article/details/111243453
问题：
1.手动获取正立的图片模板
2.定义相同的名称
3.速度太慢

%%time
"""
线程CreateAngleImage来创建全部旋转的图片，保存的queue_1 中
线程MatchTemplate来进行两张图片匹配的
"""
%%time
"""
线程1来创建全部旋转的图片，保存的queue_1 中
线程2来进行两张图片匹配的
"""
import time
from PIL import Image
from queue import Queue
from threading import Thread

img_path = r'F:\Desktop\1.png'
im = Image.open(img_path)

class CreateAngleImage(Thread): # 创建旋转角度的图像
    def __init__(self,angle_queue,img_queue):
        Thread.__init__(self)
        self.img_queue = img_queue
        self.angle_queue = angle_queue
    def run(self):
        global im
        while self.angle_queue.empty() == False:
            angle = self.angle_queue.get()
            out = im.rotate(angle,expand=True)
#             print(f"角度:{angle} 图片:{out}")
            self.img_queue.put((angle,out))
            time.sleep(1)#加在释放前会要50秒
            

class MatchTemplate(Thread): # 旋转图像与 模板图片匹配
 
    def __init__(self, img_queue):
        Thread.__init__(self)
        self.img_queue = img_queue
 
    def run(self):
        while self.img_queue.empty() == False:
            angle,out = self.img_queue.get()
#             out.show(f'{angle}.png')
            print(f"角度:{angle} 图片:{out}")
            time.sleep(1)#加在释放前会要50秒
            
                
if __name__ == '__main__':
    
    # 存储旋转角度angle的容器
    angle_queue = Queue(90)
    # 存储图片的容器
    img_queue = Queue(90)
    
    for i in range(0, 180, 3):
        angle_queue.put(i)
        
    crawl_list = []
    for num in range(10):
        crawl = CreateAngleImage(angle_queue,img_queue)
        crawl_list.append(crawl)
        crawl.start()
    for crawl in crawl_list:
        crawl.join()
        
    parser_list = []
    for i in range(15):
        parser = MatchTemplate(img_queue)
        parser_list.append(parser)
        parser.start()
    for parser in parser_list:
        parser.join()

输出：

角度:177 图片:<PIL.Image.Image image mode=RGB size=662x434 at 0x51469A0>
Wall time: 10.4 s

%%time

import threading
import time,asyncio,random
from abc import abstractmethod,ABC
import nest_asyncio
nest_asyncio.apply()
import logging
logger = logging.getLogger()
logging.basicConfig(format=f"[line:%(lineno)d] - %(asctime)s - %(funcName)s - %(processName)s - %(threadName)s: >>> %(message)s", 
                    datefmt="%H:%M:%S", # 返回2016/05/26 03:12:56 PM
                    level=logging.INFO,
                   )
import time
from PIL import Image
from queue import Queue
from threading import Thread

img_path = r'F:\Desktop\1.png'
im = Image.open(img_path)



async def worker(name, angle_queue,img_queue):
    while not angle_queue.empty():
        # 从队列中取出“工作项”
        angle = await angle_queue.get()
        # 睡上几秒钟。
        await asyncio.sleep(1)
        out = im.rotate(angle,expand=True)
        img_queue.put_nowait((angle,out))
        
        logger.info(f"{name} 角度:{angle} 图片:{out}")
        # 通知队列“工作项”已被处理。
        angle_queue.task_done()
#         logger.info(f'{name} has slept for {angle} seconds')

    
async def main():
    # 1. 创建一个队列，用于存储“工作负载”
    angle_queue = asyncio.Queue()
    img_queue = asyncio.Queue()
    # 1.1 生成随机计时并将它们放入队列中
    for i in range(0, 180, 3):
        angle_queue.put_nowait(i)

    # 2. 创建三个辅助任务以同时处理队列
    tasks = []
    for i in range(10):
        tasks.append(asyncio.create_task(worker(f'worker-{i}', angle_queue,img_queue)))

        
    # 3. 等待队列完全处理
    await angle_queue.join()

    print(img_queue)
    # 4. 这里还有运行的就是等待太久的或者错误(取消Tasks列表里正在运行的对象)
    for task in tasks:
        task.cancel()
    # 5. 异常会和成功的结果一样处理，并聚合至结果列表(再次执行未完成的异步任务)
    await asyncio.gather(*tasks, return_exceptions=True)

    logger.info('==='*10)


if __name__=='__main__':
    asyncio.run(main())
    # Wall time: 6.18 s

import time
import asyncio
import queue
import threading
import uuid
import random
import logging


from PIL import Image

img_path = r'C:\Users\lenovo\Desktop\015.jpg'
im = Image.open(img_path)

logging.basicConfig( format="%(asctime)s %(processName)s %(threadName)s >>> %(message)s", level=logging.INFO)

# -*- coding:utf8 -*-
import time
import random
import asyncio
import math

class Producer_Consumer_Model:
    def __init__(self, c_num=1, p_num=1, size=1000000):
        """
        生产者消费者模型
        :param c_num: 消费者个数
        :param p_num: 生产者个数
        :param size: 需要处理的数据大小
        """
        self.consumer_num = c_num
        self.producer_num = p_num
        self.size = size
        self.angle=0

    async def consumer(self, buffer, name):
        for _ in iter(int, 1):  # 死循环，秀一波python黑魔法
            try:
                # 从缓冲区取数，如果超过设定时间取不到数则证明协程任务结束
                angle,out = await asyncio.wait_for(buffer.get(), timeout=0.5)
                logging.info(f"角度:{angle} 图片:{out}")
                # out.show()
            except asyncio.TimeoutError:
                break

    async def producer(self, buffer, name):
        for i in range(self.size // self.producer_num):  # 将处理数据总数按生产者个数进行切分
            self.angle +=3
            out = im.rotate(self.angle,expand=True)
            await buffer.put((self.angle,out))  # 放入缓冲区
            
            

    async def main(self):
        buffer = asyncio.Queue()  # 定义缓冲区
        jobers = []  # 工作列表
        # 将生成者和消费者都加入工作列表
        for i in range(self.consumer_num):
            # 给消费者传入公共缓冲区和该消费者名字
            jobers.append(asyncio.create_task(self.consumer(buffer, 'Consumer' + str(i + 1))))
        for i in range(self.producer_num):
            # 给消费者传入公共缓冲区和该消费者名字
            jobers.append(asyncio.create_task(self.producer(buffer, 'Producer' + str(i + 1))))

        for j in jobers:
            # 打工人开始上班了
            await asyncio.gather(j)


if __name__ == '__main__':
    pc_model = Producer_Consumer_Model(c_num=2, p_num=2, size=10)
    asyncio.run(pc_model.main())  # 开启协程服务