Как устанавливать библиотеки в python windows — Ваш верный помощник с OS Windows

In this blog we explained how a simple python script can be used to stream the color camera with OpenCV Python.

For more advanced features like support for standard UVC controls and Image capture options along with camera streaming, you may refer the following blog: https://www.e-consystems.com/blog/camera/camera-board/interface-high-quality-cameras-with-opencv-python/

Open Computer Vision (OpenCV) is an open source BSD licensed image processing bundle that contains functions for all type of image processing functionality from basic image decoding, enhancement, color space conversion, object detection, object tracking and so on.

This blog is intended to show how to stream and use the USB cameras for OpenCV by using a simple Python script.

See3CAM Cameras

See3CAM is the USB 3.0 camera series from e-con Systems™. These cameras are UVC-compliant that has Plug & Play support on Windows/Linux which does not require to install additional device drivers manually.

Tested e-con Cameras:

See3CAM_CU135 – 13MP 4K USB Camera
See3CAM_130 – 13MP Auto focus USB 3.0 camera
See3CAM_160 – 16MP (4K) Autofocus USB 3.1 Gen 1 Camera
See3CAM_CU81 – AR0821 4K HDR USB Camera with 1/1.7″ sensor
See3CAM_50CUG – 5MP Sony® Pregius IMX264 Global Shutter Color Camera
See3CAM_CU55 – 5MP Low Noise USB Camera
See3CAM_CU30 – 3.4 MP Low Light USB Camera
See3CAM_24CUG – AR0234CS Full HD Color Global Shutter Camera
See3CAM_CU27 – Full HD Sony® Starvis™ IMX462 Ultra Low Light USB 3.1 Gen 1 Camera
See3CAM_CU22 – Full HD AR0233 HDR USB Camera with LFM
See3CAM_CU20 – Wide temperature range USB3 HDR Camera

For this sample application, we are going to use e-con Systems™ 13MP Auto focus USB 3.0 camera – See3CAM_130. We’ll see step by step procedure on how to access the See3CAM_130 camera from a simple OpenCV-Python application, which will grab the frame from camera and display in the preview window.

Let us start from building the OpenCV and its dependencies in Ubuntu PC.

Test System:

Host PC: Ubuntu-18.04 and 20.04 (Linux) and Windows 8 and 10
OpenCV Version: 4.6
Python Version: 3.9

Download OpenCV source

Download the required OpenCV version for Linux from the following command

$ wget https://github.com/opencv/opencv/archive/4.6.zip

Install Dependencies:

OpenCV requires the following dependencies to work with the USB cameras. Install the dependencies from the following commands:

# libav video input/output development libraries $ sudo apt-get install libavformat-dev libavutil-dev libswscale-dev # Video4Linux camera development libraries $ sudo apt-get install libv4l-dev # OpenGL development libraries (to allow creating graphical windows) $ sudo apt-get install libglew-dev # GTK development libraries (to allow creating graphical windows) $ sudo apt-get install libgtk2.0-dev # Install the OpenCV python $ sudo apt-get install python-opencv

Configure and build the OpenCV from source:

After installing the dependencies, now we need to build and install OpenCV using the following commands:

$ unzip opencv-4.6.zip $ cd opencv-4.6 $ mkdir build && cd build $ cmake -D CMAKE_BUILD_TYPE=RELEASE -D WITH_TBB=OFF -D BUILD_TBB=OFF -D WITH_V4L=ON -D WITH_LIBV4L=OFF -D BUILD_TESTS=OFF -D BUILD_PERF_TESTS=OFF ..

Compile and install:

The following command will build and install OpenCV libraries in the location – “/usr/local/lib/”

$ sudo make j4 install

We now have built & installed OpenCV in the Ubuntu PC. Let us look how to prepare a sample Python application to stream the camera using OpenCV.

The following sample OpenCV python code explain how to open the device video node, set the resolution, grab the frame and then display the frame in preview window.

Import the OpenCV python package

import cv2

Open the camera video node to access the See3CAM_130

# Open the device at the ID 0 cap = cv2.VideoCapture(0) # Check whether user selected camera is opened successfully. if not (cap.isOpened()): print("Could not open video device")

Set the resolution of the camera by using OpenCV camera control properties

# To set the resolution cap.set(cv2.cv.CV_CAP_PROP_FRAME_WIDTH, 640) cap.set(cv2.cv.CV_CAP_PROP_FRAME_HEIGHT, 480)

Grab the frame continuously from the camera and show it in the preview window using the while loop. Enter ‘q’ key, to break the loop and exit the application

while(True): # Capture frame-by-frame ret, frame = cap.read() # Display the resulting frame cv2.imshow('preview',frame) # Waits for a user input to quit the application if cv2.waitKey(1) & 0xFF == ord('q'): break

Release the camera, then close all of the imshow() windows.

# When everything done, release the capture cap.release() cv2.destroyAllWindows()

Save the sample code as “camera_stream.py”.

import cv2 # Open the device at the ID 0 cap = cv2.VideoCapture(0) # Check whether user selected camera is opened successfully. if not (cap.isOpened()): print("Could not open video device") # To set the resolution cap.set(cv2.cv.CV_CAP_PROP_FRAME_WIDTH, 640) cap.set(cv2.cv.CV_CAP_PROP_FRAME_HEIGHT, 480) while(True): # Capture frame-by-frame ret, frame = cap.read() # Display the resulting frame cv2.imshow('preview',frame) # Waits for a user input to quit the application if cv2.waitKey(1) & 0xFF == ord('q'): break # When everything done, release the capture cap.release() cv2.destroyAllWindows()

Now compile and run the program:

python2 camera_stream.py

Источник

Как в Python 3 получить изображения с web-камеры, какой модуль можно использовать в этих целях?

Вопрос задан

более трёх лет назад
17422 просмотра

Можно использовать модуль opencv

import cv2

# Включаем первую камеру
cap = cv2.VideoCapture(0)

# "Прогреваем" камеру, чтобы снимок не был тёмным
for i in range(30):
    cap.read()

# Делаем снимок    
ret, frame = cap.read()

# Записываем в файл
cv2.imwrite('cam.png', frame)   

# Отключаем камеру
cap.release()

Пригласить эксперта

no module named ‘cv2’
Как исправить?

@@QWERTYUIOPas
пропиши в командной строке pip install opencv-python

Показать ещё
Загружается…

Минуточку внимания

Источник

В OpenCV существует множество вариантов для трансляции видеопотока. Можно использовать один из них – IP-камеры, но с ними бывает довольно трудно работать. Так, некоторые IP-камеры не позволяют получить доступ к RTSP-потоку (англ. Real Time Streaming Protocol). Другие IP-камеры не работают с функцией OpenCV cv2.VideoCapture. В конце концов, такой вариант может быть слишком дорогостоящим для ваших задач, особенно, если вы хотите построить сеть из нескольких камер.

Как отправлять видеопоток со стандартной веб-камеры с помощью OpenCV? Одним из удобных способов является использование протоколов передачи сообщений и соответствующих библиотек ZMQ и ImageZMQ.

Поэтому сначала мы кратко обсудим транспорт видеопотока вместе с ZMQ, библиотекой для асинхронной передачи сообщений в распределенных системах. Далее, мы реализуем два скрипта на Python:

Клиент, который будет захватывать кадры с простой веб-камеры.
Сервер, принимающий кадры и ищущий на них выбранные типы объектов (например, людей, собак и автомобили).

Для демонстрации работы узлов применяются четыре платы Raspberry Pi с подключенными модулями камер. На их примере мы покажем, как использовать дешевое оборудование в создании распределенной сети из камер, способных отправлять кадры на более мощную машину для дополнительной обработки.

Передача сообщений и ZMQ

Передача сообщений – парадигма программирования, традиционно используемая в многопроцессорных распределенных системах. Концепция предполагает, что один процесс может взаимодействовать с другими процессами через посредника – брокера сообщений (англ. message broker). Посредник получает запрос, а затем обрабатывает акт пересылки сообщения другому процессу/процессам. При необходимости брокер сообщений также отправляет ответ исходному процессу.

ZMQ является высокопроизводительной библиотекой для асинхронной передачи сообщений, используемой в распределенных системах. Этот пакет обеспечивает высокую пропускную способность и малую задержку. На основе ZMQ Джефом Бассом создана библиотека ImageZMQ, которую сам Джеф использует для компьютерного зрения на своей ферме вместе с теми же платами Raspberry Pi.

Пишем программу для автоматического распознавания объектов с веб-камер

Начнем с того, что настроим клиенты и сервер.

Конфигурирование системы и установка необходимых пакетов

Сначала установим opencv и ZMQ. Чтобы избежать конфликтов, развертывание проведем в виртуальной среде:

        $ workon <env_name> # например, py3cv4
$ pip install opencv-contrib-python
$ pip install zmq
$ pip install imutils

Теперь нам нужно клонировать репозиторий с ImageZMQ:

        $ cd ~
$ git clone https://github.com/jeffbass/imagezmq.git

Далее, можно скопировать директорию с исходником или связать ее с вашим виртуальным окружением. Рассмотрим второй вариант:

        $ cd ~/.virtualenvs/py3cv4/lib/python3.6/site-packages
$ ln -s ~/imagezmq/imagezmq imagezmq

Библиотеку ImageZMQ нужно установить и на сервер, и на каждый клиент.

Примечание: чтобы быть увереннее в правильности введенного пути, используйте дополнение через табуляцию.

Подготовка клиентов для ImageZMQ

В этом разделе мы осветим важное отличие в настройке клиентов.

Наш код будет использовать имя хоста клиента для его идентификации. Для этого достаточно и IP-адреса, но настройка имени хоста позволяет проще считать назначение клиента.

В нашем примере для определенности мы предполагаем, что вы используете Raspberry Pi с операционной системой Raspbian. Естественно, что клиент может быть построен и на другой ОС.

Чтобы сменить имя хоста, запустите терминал (это можно сделать через SSH-соединение) и введите команду raspi-config:

        $ sudo raspi-config

Вы увидите следующее окно терминала. Перейдите к пункту 2 Network Options.

На следующем шаге выберите опцию N1 Hostname.

На этом этапе задайте осмысленное имя хоста (например, pi-livingroom, pi-bedroom, pi-garage). Так вам будет легче ориентироваться в клиентах сети и сопоставлять имена и IP-адреса.

Далее, необходимо согласиться с изменениями и перезагрузить систему.

В некоторых сетях вы можете подключиться через SSH, не предоставляя IP-адрес явным образом:

        $ ssh pi@pi-frontporch

Определение отношений сервер-клиент

Прежде чем реализовать стриминг потокового видео по сети, определим отношения клиентов и сервера. Для начала уточним терминологию:

Клиент – устройство, отвечающее за захват кадров с веб-камеры с использованием OpenCV, а затем за отправку кадров на сервер.
Сервер — компьютер, принимающий кадры от всех клиентов.

Конечно, и сервер, и клиент могут и принимать, и отдавать какие-то данные (не только видеопоток), но для нас важно следующее:

Существует как минимум одна (а скорее всего, несколько) система, отвечающая за захват кадров (клиент).
Существует только одна система, используемая для получения и обработки этих кадров (сервер).

Структура проекта

Структура проекта будет состоять из следующих файлов:

        $ $ tree
.
├── MobileNetSSD_deploy.caffemodel
├── MobileNetSSD_deploy.prototxt
├── client.py
└── server.py
 
0 directories, 4 files

Два первых файла из списка соответствуют файлам предобученной нейросети Caffe MobileNet SSD для распознавания объектов. В репозитории по ссылке можно найти соответствующие файлы, чьи названия, правда, могут отличаться от приведенных (*.caffemodel и deploy.prototxt). Сервер (server.py) использует эти файлы Caffe в DNN-модуле OpenCV.

Скрипт client.py будет находиться на каждом устройстве, которое отправляет поток на сервер.

Реализация клиентского стримера на OpenCV

Начнем с реализации клиента. Что он будет делать:

Захватывать видеопоток с камеры (USB или RPi-модуль).
Отправлять кадры по сети через ImageZMQ.

Откроем файл client.py и вставим следующий код:

        # импортируем необходимые библиотеки
from imutils.video import VideoStream  # захват кадров с камеры
import imagezmq
import argparse  # обработка аргумента командной строки, содержащего IP-адрес сервера
import socket    # получение имени хоста Raspberry Pi
import time      # для учета задержки камеры перед отправкой кадров
 
# создаем парсер аргументов и парсим
ap = argparse.ArgumentParser()
ap.add_argument("-s", "--server-ip", required=True,
	help="ip address of the server to which the client will connect")
args = vars(ap.parse_args())
 
# инициализируем объект ImageSender с адресом сокета сервера
sender = imagezmq.ImageSender(connect_to="tcp://{}:5555".format(
	args["server_ip"]))

Назначение импортируемых модулей описано в комментариях. В последних строчках создается объект-отправитель, которому передаются IP-адрес и порт сервера. Указанный порт 5555 обычно не вызывает конфликтов.

Инициализируем видеопоток и начнем отправлять кадры на сервер.

        # получим имя хоста, инициализируем видео поток, 
# дадим датчику камеры прогреться
rpiName = socket.gethostname()
vs = VideoStream(usePiCamera=True).start()
#vs = VideoStream(src=0).start()
time.sleep(2.0)  # задержка для начального разогрева камеры
 
while True:
	# прочитать кадр с камеры и отправить его на сервер
	frame = vs.read()
	sender.send_image(rpiName, frame)

Теперь у нас есть объект VideoStream, созданный для захвата фреймов с RPi-камеры. Если вы используете USB-камеру, раскомментируйте следующую строку и закомментируйте ту, что активна сейчас.

В этом месте вы также можете установить разрешение камеры. Мы будем использовать максимальное, так что аргумент не передастся. Если вы обнаружите задержку, надо уменьшить разрешение, выбрав одно из доступных значений, представленных в таблице. Например:

        vs = VideoStream(usePiCamera=True, resolution=(320, 240)).start()

Для USB-камеры такой аргумент не предусмотрен. В следующей строке после считывания кадра можно изменить его размер:

        frame = imutils.resize(frame, width=320)

В последних строках скрипта происходит захват и отправка кадров на сервер.

Реализация сервера

На стороне сервера необходимо обеспечить:

Прием кадров от клиентов.
Детектирование объектов на каждом из входящих кадров.
Подсчет количества объектов для каждого из кадров.
Отображение смонтированного кадра (панели), содержащего изображения от всех активных устройств.

Последовательно заполним файл с описанием сервера server.py:

        # импортируем необходимые библиотеки
from imutils import build_montages   # монтаж всех входящих кадров
from datetime import datetime
import numpy as np
import imagezmq
import argparse
import imutils
import cv2
 
# создаем парсер аргументов и парсим их
ap = argparse.ArgumentParser()
ap.add_argument("-p", "--prototxt", required=True,
	help="path to Caffe 'deploy' prototxt file")
ap.add_argument("-m", "--model", required=True,
	help="path to Caffe pre-trained model")
ap.add_argument("-c", "--confidence", type=float, default=0.2,
	help="minimum probability to filter weak detections")
ap.add_argument("-mW", "--montageW", required=True, type=int,
	help="montage frame width")
ap.add_argument("-mH", "--montageH", required=True, type=int,
	help="montage frame height")
args = vars(ap.parse_args())

Библиотека imutils упрощает работу с изображениями (есть на GitHub и PyPi).

Пять аргументов, обрабатываемых с помощью парсера argparse:

--prototxt: путь к файлу прототипа глубокого изучения Caffe.
--model: путь к предообученной модели нейросети Caffe.
--confidence: порог достоверности для фильтрации случаев нечеткого обнаружения.
--montageW: количество столбцов для монтажа общего кадра, состоящего в нашем примере из 2х2 картинок (то есть montageW = 2) . Часть ячеек может быть пустой.
--montageH: аналогично предыдущему пункту — количество строк в общем кадре.

Вначале инициализируем объект ImageHub для работы с детектором объектов. Последний построен на базе MobileNet Single Shot Detector.

        imageHub = imagezmq.ImageHub()
 
# инициализируем список меток классов сети MobileNet SSD, обученной
# для детектирования, генерируем набор ограничивающих прямоугольников
# разного цвета для каждого класса
CLASSES = ["background", "aeroplane", "bicycle", "bird", "boat",
	"bottle", "bus", "car", "cat", "chair", "cow", "diningtable",
	"dog", "horse", "motorbike", "person", "pottedplant", "sheep",
	"sofa", "train", "tvmonitor"]
 
# загружаем сериализованную модель Caffe с диска
print("[INFO] loading model...")
net = cv2.dnn.readNetFromCaffe(args["prototxt"], args["model"])

Объект ImageHub используется сервером для приема подключений от каждой платы Raspberry Pi. По существу, для получения кадров по сети и отправки назад подтверждений здесь используются сокеты и ZMQ .

Предположим, что в системе безопасности мы отслеживаем только три класса подвижных объектов: собаки, люди и автомобили. Эти метки мы запишем в множество CONSIDER, чтобы отфильтровать прочие неинтересные нам классы (стулья, растения и т. д.).

Кроме того, необходимо следить за активностью клиентов, проверяя время отправки тем или иным клиентом последнего кадра.

        # инициализируем выбранный набор подсчитываемых меток классов,
# словарь-счетчик и словарь фреймов
CONSIDER = set(["dog", "person", "car"])
objCount = {obj: 0 for obj in CONSIDER}
frameDict = {}
 
# инициализируем словарь, который будет содержать информацию
# о том когда устройство было активным в последний раз
lastActive = {}
lastActiveCheck = datetime.now()
 
# храним ожидаемое число клиентов, период активности
# вычисляем длительность ожидания между проверкой
# на активность устройства

ESTIMATED_NUM_PIS = 4
ACTIVE_CHECK_PERIOD = 10
ACTIVE_CHECK_SECONDS = ESTIMATED_NUM_PIS * ACTIVE_CHECK_PERIOD
 
# назначаем ширину и высоту монтажного кадра
# чтобы просматривать потоки от всех клиентов вместе
mW = args["montageW"]
mH = args["montageH"]
print("[INFO] detecting: {}...".format(", ".join(obj for obj in
	CONSIDER)))

Далее необходимо зациклить потоки, поступающие от клиентов и обработку данных на сервере.

        # начинаем цикл по всем кадрам
while True:
	# получаем имя клиента и кадр,
	# подтверждаем получение
	(rpiName, frame) = imageHub.recv_image()
	imageHub.send_reply(b'OK')
 
	# если устройства нет в словаре lastActive,
	# это новое подключенное устройство
	if rpiName not in lastActive.keys():
		print("[INFO] receiving data from {}...".format(rpiName))
 
	# записываем время последней активности для устройства,
	# от которого мы получаем кадр
	lastActive[rpiName] = datetime.now()

Итак, сервер забирает изображение в imageHub, высылает клиенту сообщение о подтверждении получения. Принятое сервером сообщениеimageHub.recv_image содержит имя хоста rpiName и кадр frame. Остальные строки кода нужны для учета активности клиентов.

Затем мы работаем с кадром, формируя блоб (о функции blobFromImage читайте подробнее в посте pyimagesearch). Блоб передается нейросети для детектирования объектов.

Замечание: мы продолжаем рассматривать цикл, поэтому здесь и далее будьте внимательны с отступами в коде.

        	# изменяем размер кадра, чтобы ширина была не больше 400 пикселей,
	# захватываем размеры кадров и создаем блоб
	frame = imutils.resize(frame, width=400)
	(h, w) = frame.shape[:2]
	blob = cv2.dnn.blobFromImage(cv2.resize(frame, (300, 300)),
		0.007843, (300, 300), 127.5)
 
	# передаем блоб нейросети, получаем предсказания
	net.setInput(blob)
	detections = net.forward()
 
	# сбрасываем число объектов для интересующего набора
	objCount = {obj: 0 for obj in CONSIDER}

Теперь мы хотим пройтись по детектированным объектам, чтобы посчитать и выделить их цветными рамками:

        	# циклически обходим детектированные объекты
	for i in np.arange(0, detections.shape[2]):
		# извлекаем вероятность соответствующего предсказания
		confidence = detections[0, 0, i, 2]
 
		# отфильтруем слабые предсказания,	
		# гарантируя минимальную достоверность
		if confidence > args["confidence"]:
			# извлекаем индекс метки класса
			idx = int(detections[0, 0, i, 1])
 
			# проверяем, что метка класса в множестве интересных нам
			if CLASSES[idx] in CONSIDER:
				# подсчитываем детектированный объект
				objCount[CLASSES[idx]] += 1
 
				# вычисляем координаты рамки, ограничивающей объект
				box = detections[0, 0, i, 3:7] * np.array([w, h, w, h])
				(startX, startY, endX, endY) = box.astype("int")
 
				# рисуем рамку вокруг объекта
				cv2.rectangle(frame, (startX, startY), (endX, endY),
					(255, 0, 0), 2)

Далее, аннотируем каждый кадр именем хоста и количеством объектов. Наконец, монтируем из нескольких кадров общую панель:

        	# отобразим имя клиента на кадре
	cv2.putText(frame, rpiName, (10, 25),
		cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 0, 255), 2)
 
	# отобразим число объектов на кадре
	label = ", ".join("{}: {}".format(obj, count) for (obj, count) in
		objCount.items())
	cv2.putText(frame, label, (10, h - 20),
		cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 255,0), 2)
 
	# обновим кадр в словаре кадров клиентов
	frameDict[rpiName] = frame
 
	# построим общий кадр из словаря кадров
	montages = build_montages(frameDict.values(), (w, h), (mW, mH))
 
	# покажем смонтированный кадр на экране
	for (i, montage) in enumerate(montages):
		cv2.imshow("Home pet location monitor ({})".format(i),
			montage)
 
	# детектируем нажатие какой-либо клавиши
	key = cv2.waitKey(1) & 0xFF

Остался заключительный блок для проверки последних активностей всех клиентов. Эти операции особенно важны в системах безопасности, чтобы при отключении клиента вы не наблюдали неизменный последний кадр.

        	# если разница между текущим временем и временем последней активности 
	# больше порога, производим проверку
	if (datetime.now() - lastActiveCheck).seconds > ACTIVE_CHECK_SECONDS:
		# циклично обходим все ранее активные устройства
		for (rpiName, ts) in list(lastActive.items()):
			# удаляем клиент из словарей кадров и последних активных
			# если устройство неактивно
			if (datetime.now() - ts).seconds > ACTIVE_CHECK_SECONDS:
				print("[INFO] lost connection to {}".format(rpiName))
				lastActive.pop(rpiName)
				frameDict.pop(rpiName)
 
		# устанавливаем время последней активности
		lastActiveCheck = datetime.now()
 
	# если нажата клавиша `q`, выходим из цикла
	if key == ord("q"):
		break
 
# закрываем окна и освобождаем память
cv2.destroyAllWindows()

Запускаем стриминг видео с камер

Теперь, когда мы реализовали и клиент, и сервер, проверим их. Загрузим клиент на каждую плату Raspberry Pi с помощью SCP-протокола:

        $ scp client.py pi@192.168.1.10:~
$ scp client.py pi@192.168.1.11:~
$ scp client.py pi@192.168.1.12:~
$ scp client.py pi@192.168.1.13:~

Проверьте, что на всех машинах установлены импортируемые клиентом или сервером библиотеки. Первым нужно запускать сервер. Сделать это можно следующей командой:

        $ python server.py --prototxt MobileNetSSD_deploy.prototxt \
	--model MobileNetSSD_deploy.caffemodel --montageW 2 --montageH 2

Далее запускаем клиенты, следуя инструкции (будьте внимательны, в вашей системе имена и адреса могут отличаться):

Откройте SSH-соединение с клиентом: ssh pi@192.168.1.10
Запустите экран клиента: screen
Перейдите к профилю: source ~/.profile
Активируйте окружение: workon py3cv4
Установите ImageZMQ, следуя инструкциям библиотеки по установке
Запустите клиент: python client.py --server-ip 192.168.1.5

Ниже представлено демо-видео панели с процессом стриминга и распознавания объектов с четырех камер на Raspberry Pi.

Аналогичные решения из кластера камер и сервера можно использовать и для других задач, например:

Распознавание лиц. Такую систему можно использовать в школах для обеспечения безопасности и автоматической оценки посещаемости.
Робототехника. Объединяя несколько камер и компьютерное зрение, вы можете создать прототип системы автопилота.
Научные исследования. Кластер из множества камер позволяет проводить исследования миграции птиц и животных. При этом можно автоматически обрабатывать фотографии и видео только в случае детектирования конкретного вида, а не просматривать видеопоток целиком.

А какие у вас есть идеи для использования нескольких камер и OpenCV?

Источник

Last Updated :
07 Aug, 2024

Prerequisite: Python Language Introduction OpenCV is the huge open-source library for computer vision, machine learning, and image processing and now it plays a major role in real-time operation which is very important in today’s systems. By using it, one can process images and videos to identify objects, faces, or even the handwriting of a human. When it integrated with various libraries, such as Numpy, python is capable of processing the OpenCV array structure for analysis. To Identify image patterns and its various features we use vector space and perform mathematical operations on these features. To install OpenCV, one must have Python and PIP, preinstalled on their system. To check if your system already contains Python, go through the following instructions: Open the Command line(search for cmd in the Run dialog( + R). Now run the following command:

python --version

If Python is already installed, it will generate a message with the Python version available.

If Python is not present, go through How to install Python on Windows? and follow the instructions provided. PIP is a package management system used to install and manage software packages/libraries written in Python. These files are stored in a large “on-line repository” termed as Python Package Index (PyPI). To check if PIP is already installed on your system, just go to the command line and execute the following command:

pip -V

If PIP is not present, go through How to install PIP on Windows? and follow the instructions provided.

Downloading and Installing OpenCV:

OpenCV can be directly downloaded and installed with the use of pip (package manager). To install OpenCV, just go to the command-line and type the following command:

pip install opencv-python

Beginning with the installation:

To check if OpenCV is correctly installed, just run the following commands to perform a version check:

python
>>>import cv2
>>>print(cv2.__version__)

Источник

Чтобы не писать нужные функции с нуля каждый раз, разработчики используют библиотеки. Это наборы готового кода для выполнения какой-то задачи — например, математическая библиотека numpy содержит функции для работы с числами.

Большинство библиотек не подключены к языку программирования по умолчанию. Их нужно загружать отдельно. Разберемся, как сделать это в Python — одном из самых популярных языков программирования.

Способ №1. Установить библиотеку вручную

Большинство пакетов с библиотеками Python собрано на сайте под названием PyPI. На его главной странице есть окно поиска, через которое можно найти интересующий пакет. А затем открыть его страницу и увидеть информацию по нему.

Сайт предлагает скачать и установить любой пакет двумя способами:

с помощью команды пакетного менеджера pip;
вручную — для этого нужно скачать архив с библиотекой с сайта PyPI.

После того как файл загрузится на компьютер, его нужно будет разархивировать. А затем — открыть консоль командной строки и перейти в папку, где лежит пакет. Там в терминале нужно будет выполнить команду:

python setup.py install

Эта команда с помощью Python запускает файл setup.py — в пакете он отвечает за установку компонентов.

Если возникает ошибка — скорее всего дело в том, что командная строка не понимает, где находится Python. В таком случае можно прописать полный путь к папке, где находятся файлы языка.

Способ №2. Использовать easy install

Для Python существует модуль под названием easy install. Он позволяет быстро устанавливать в язык новые расширения — понадобится всего лишь написать одну команду. Скачать этот модуль проще всего вместе с расширением setuptools — оно есть на PyPI, и его можно установить вручную способом из предыдущего пункта.

После того как утилита установится, можно будет загрузить библиотеку в Python через нее. Для этого нужно из папки, где установлен setuptools, вызвать в терминале команду:

easy_install <имя пакета>

Вместо <имя пакета> нужно подставить название интересующей библиотеки, которое можно посмотреть на PyPI или ее официальном сайте. Инструмент скачает и установит библиотеку автоматически.

Пользоваться easy install можно и из других папок — но понадобится прописывать полный путь к утилите. Правда, если установить ее в корневой каталог операционной системы, это делать не понадобится — ОС будет «видеть» утилиту, из какой бы папки ее ни вызвали.

У easy install есть два ограничения:

с ее помощью нельзя удалить какую-то библиотеку или отключить ее;
иногда при использовании возникают ошибки — она может попытаться запустить не установленную на компьютер библиотеку.

Способ №3. Использовать pip

Это самый популярный способ установки библиотек в Python. Для языка существует менеджер пакетов под названием pip. С его помощью устанавливать новые компоненты можно буквально с помощью одной команды.

Начиная с Python версии 3.4 pip устанавливается вместе с самим языком. Его не нужно скачивать отдельно. Это понадобится, только если вы работаете с какой-то из более старых версий.

Проверить, установлен ли pip, можно с помощью команды в терминале:

pip --version

Если менеджер уже установлен, высветится его версия. Если нет — появится сообщение, что такого пакета в системе нет. В таком случае pip можно скачать с PyPI и установить ручным способом.

Также pip можно загрузить с сайта PyPa — рабочей группы, которая занимается его разработкой. Вручную это можно сделать в любой системе. В Linux также возможно скачать его с помощью команды в терминале:

wget https://bootstrap.pypa.io/get-pip.py

Или с помощью easy install:

easy_install pip

Оба способа позволяют скачать файл get-pip.py. После этого его нужно запустить в Python через терминал:

python get-pip.py

После того как pip загрузится и инсталлируется, его можно будет использовать для установки библиотек. Это просто — фактически установить нужный пакет можно с помощью одной команды. Но возможности pip куда шире, чем у easy install.

Менеджер умеет не только устанавливать, но и обновлять или удалять библиотеки в Python. А еще — подгружать зависимости, то есть модули, нужные для работы какой-то из библиотек.

Установить модуль в Python с помощью pip можно так:

pip install <имя пакета>

Кроме того, есть еще несколько команд, которые могут понадобиться при работе с библиотеками:

pip install -U <имя пакета> — обновить библиотеку до актуальной версии;
pip install <имя пакета>==<номер версии> — установить библиотеку какой-то конкретной версии;
pip install —force-reinstall <имя пакета> — принудительно переустановить библиотеку, например если та установилась с ошибками;
pip uninstall <имя пакета> — удалить библиотеку, которая перестала быть нужной;
pip list — посмотреть список установленных пакетов;
pip show <имя пакета> — посмотреть информацию о конкретном установленном пакете.

Достаточно ввести нужную команду в терминал, и pip автоматически выполнит нужное действие.

Что еще стоит сделать

Каким бы способом вы ни пользовались, после установки нужно проверить, точно ли пакет работает нормально. Для этого достаточно подключить библиотеку к Python-коду и попробовать ее использовать.

Чтобы конкретная программа «увидела» нужный модуль, его нужно добавить в код с помощью строчки:

import <имя пакета>

Обычно модули подключают в самом начале файла с кодом. То есть, первые строки программы — добавление библиотек, нужных для ее работы.

После этого можно использовать в коде нужные функции и компоненты из библиотеки. Если все установилось как следует, при этом не должно возникнуть никаких ошибок. Готово — нужными модулями можно пользоваться на свое усмотрение.

Источник