Problema errore lettura telecamera(OpenCV/Py)

[alien75]

Ho il seguente codice:

Codice: Seleziona tutto

import numpy as np
import cv2
import cv2 as cv
import sys
import os
from tempfile import TemporaryFile

outfile = TemporaryFile()

class NeuralNetwork:
    def __init__(self, input_size, hidden_size, output_size):
        self.input_size = input_size
        self.hidden_size = hidden_size
        self.output_size = output_size

        self.weights_input_hidden = np.random.randn(self.input_size, self.hidden_size)
        self.weights_hidden_output = np.random.randn(self.hidden_size, self.output_size)
       

        self.bias_hidden = np.zeros((1, self.hidden_size))
        self.bias_output = np.zeros((1, self.output_size))
       
    def sigmoid(self, x):
        return 1 / (1 + np.exp(-x))

    def sigmoid_derivative(self, x):
        return x * (1 - x)

    def feedforward(self, X):
        self.hidden_activation = np.dot(X, self.weights_input_hidden) + self.bias_hidden
        self.hidden_output = self.sigmoid(self.hidden_activation)

        self.output_activation = np.dot(self.hidden_output, self.weights_hidden_output) + self.bias_output
        self.predicted_output = self.sigmoid(self.output_activation)

        return self.predicted_output

    def backward(self, X, y, learning_rate):
        output_error = y - self.predicted_output
        output_delta = output_error * self.sigmoid_derivative(self.predicted_output)

        hidden_error = np.dot(output_delta, self.weights_hidden_output.T)
        hidden_delta = hidden_error * self.sigmoid_derivative(self.hidden_output)

        self.weights_hidden_output += np.dot(self.hidden_output.T, output_delta) * learning_rate
        self.bias_output += np.sum(output_delta, axis=0, keepdims=True) * learning_rate
        self.weights_input_hidden += np.dot(X.T, hidden_delta) * learning_rate
        self.bias_hidden += np.sum(hidden_delta, axis=0, keepdims=True) * learning_rate

    def train(self, X, y, epochs, learning_rate):
        for epoch in range(epochs):
            output = self.feedforward(X)
            self.backward(X, y, learning_rate)
            if epoch % 4000 == 0:
                loss = np.mean(np.square(y - output))
                print(f"Epoch {epoch}, Loss:{loss}")

IMAGE1 = 'day_open.jpg'
IMAGE2 = 'day_closed.jpg'
IMAGE3 = 'night_open.jpg'
IMAGE4 = 'night_closed.jpg'
IMAGE5 = 'DX.jpg'
IMAGE6 = 'SX.jpg'
IMAGE7 = 'DX1.jpg'

image1 = cv2.imread(IMAGE1)
image2 = cv2.imread(IMAGE2)
image3 = cv2.imread(IMAGE3)
image4 = cv2.imread(IMAGE4)
image5 = cv2.imread(IMAGE5)
image6 = cv2.imread(IMAGE6)
image7 = cv2.imread(IMAGE7)

gray_image1 = cv2.cvtColor(image1, cv2.COLOR_BGR2GRAY)
gray_image1 = cv2.resize(gray_image1,(100, 100), interpolation = cv2.INTER_CUBIC)
gray_image2 = cv2.cvtColor(image2, cv2.COLOR_BGR2GRAY)
gray_image2 = cv2.resize(gray_image2,(100, 100), interpolation = cv2.INTER_CUBIC)
gray_image3 = cv2.cvtColor(image3, cv2.COLOR_BGR2GRAY)
gray_image3 = cv2.resize(gray_image3,(100, 100), interpolation = cv2.INTER_CUBIC)
gray_image4 = cv2.cvtColor(image4, cv2.COLOR_BGR2GRAY)
gray_image4 = cv2.resize(gray_image4,(100, 100), interpolation = cv2.INTER_CUBIC)
gray_image5 = cv2.cvtColor(image5, cv2.COLOR_BGR2GRAY)
gray_image5 = cv2.resize(gray_image5,(100, 100), interpolation = cv2.INTER_CUBIC)
gray_image6 = cv2.cvtColor(image6, cv2.COLOR_BGR2GRAY)
gray_image6 = cv2.resize(gray_image6,(100, 100), interpolation = cv2.INTER_CUBIC)
gray_image7 = cv2.cvtColor(image7, cv2.COLOR_BGR2GRAY)
gray_image7 = cv2.resize(gray_image7,(100, 100), interpolation = cv2.INTER_CUBIC)

gray_image1 = gray_image1 / 255
gray_image2 = gray_image2 / 255
gray_image3 = gray_image3 / 255
gray_image4 = gray_image4 / 255
gray_image5 = gray_image5 / 255
gray_image6 = gray_image6 / 255
gray_image7 = gray_image7 / 255

X=np.array([gray_image1.reshape(10000),gray_image2.reshape(10000),gray_image3.reshape(10000),gray_image4.reshape(10000),gray_image5.reshape(10000),gray_image6.reshape(10000)])
y=np.array([[0,1,0,0],[0,0,0,0],[0,1,0,0],[0,0,0,0],[0,1,1,0],[0,1,0,1]])
print("output = ", y)

WIH="wih.npy"
WHO="who.npy"

nn = NeuralNetwork(input_size=10000, hidden_size=300, output_size=4)
if os.path.exists(WIH) and os.path.exists(WHO):
    #caricamento pesi tra ingresso e strato di hidden
    print(f'caricamento wih')
    nn.weights_input_hidden = np.load(WIH)
    #caricamento pesi tra strato di hidden ed uscita
    print(f'caricamento who')
    nn.weights_hidden_output = np.load(WHO)
else:
   print(f'training')
   nn.train(X, y, epochs=700, learning_rate=0.8)
   #salvataggio pesi tra ingresso e strato hidden
   wih = nn.weights_input_hidden
   np.save(WIH, wih)
   #salvataggio pesi tra strato hidden e uscita   
   who = nn.weights_hidden_output
   np.save(WHO, who)
   

print("Predictions after training:")
print(f'  image1 {nn.feedforward(gray_image1.reshape(1,10000))}')
print(f'  image2 {nn.feedforward(gray_image2.reshape(1,10000))}')
print(f'  image3 {nn.feedforward(gray_image3.reshape(1,10000))}')
print(f'  image4 {nn.feedforward(gray_image4.reshape(1,10000))}')
print(f'  image5 {nn.feedforward(gray_image5.reshape(1,10000))}')
print(f'  image6 {nn.feedforward(gray_image6.reshape(1,10000))}')
print(f'  image7 {nn.feedforward(gray_image7.reshape(1,10000))}')

while True:
    cap = cv.VideoCapture(0)
    if not cap.isOpened():
        print("Cannot open camera")
        exit()
    # Capture frame-by-frame
    ret, frame = cap.read()
    gray_image1 = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
    gray_image1 = cv2.resize(gray_image1,(100, 100), interpolation =
cv2.INTER_CUBIC)
    #cv.imshow("Display window", gray_image1)
    #k = cv.waitKey(0)
    gray_image1 = gray_image1 / 255
    print("Predictions after training:")
    print(f'  image1 {nn.feedforward(gray_image1.reshape(1,10000))}')


ed ottengo il seguente messaggio di errore:

Codice: Seleziona tutto

output =  [[0 1 0 0]
[0 0 0 0]
[0 1 0 0]
[0 0 0 0]
[0 1 1 0]
[0 1 0 1]]
caricamento wih
caricamento who
Predictions after training:
  image1 [[1.27132098e-03 9.94429034e-01 1.29911218e-06 1.00000000e+00]]
  image2 [[1.48849602e-06 3.20656101e-06 1.35191542e-03 9.99999999e-01]]
  image3 [[2.48041896e-08 9.99999952e-01 3.40170904e-07 1.00000000e+00]]
  image4 [[2.94269280e-05 5.07023377e-10 3.94733197e-04 9.99999994e-01]]
  image5 [[4.27285717e-04 9.98542453e-01 9.99999901e-01 9.99994018e-01]]
  image6 [[1.75611959e-03 9.99998415e-01 6.93325269e-04 9.99992124e-01]]
  image7 [[8.60520542e-01 9.99900309e-01 2.20303752e-06 9.99999999e-01]]
Predictions after training:
  image1 [[0.92460133 0.14056893 0.2178598  0.98757831]]
[ WARN:0@1.894] global cap_v4l.cpp:913 open VIDEOIO(V4L2:/dev/video0): can't open camera by index
[ERROR:0@1.894] global obsensor_uvc_stream_channel.cpp:158 getStreamChannelGroup Camera index out of range
Cannot open camera


perché mi da tale errore?

[xyz]

[ WARN:0@1.894] global cap_v4l.cpp:913 open VIDEOIO(V4L2:/dev/video0): can't open camera by index

Basta leggere con attenzione l'errore, non hai il device "/dev/video0" o non è accessibile

[alien75]

ho dato:

Codice: Seleziona tutto

ls -la /dev/video0


e mi dice:

Codice: Seleziona tutto

crwxrwxrwx+ 1 root video 81, 0 apr  1 17:20 /dev/video0


Ho in permessi 777 quindi la cam dovrebbe funzionare sia in scrittutra che lettura, perché allora continua a darmi quel errore?

Il messaggio di errore nel primo posto mi comunica un errore di tipo V4L2 o una cosa del genere
Il tutorial mi dice che c'è una costante cv.CAP_V4L2 in python ma non capisco a cosa si riferisce.

[xyz]

Ho in permessi 777 quindi la cam dovrebbe funzionare sia in scrittutra che lettura, perché allora continua a darmi quel errore?

Da utente di sistemi operativi POSIX vedere gli attributi 777 è terribile per la sicurezza. Comunque potresti avere il device utilizzato da un altro programma quindi non lo puoi riaprire.

CAP_V4L2 è una costante del modulo Python cv2 (OpenCV).

[angus]

non dovrebbe essere un problema di permessi.
cosa dice modificando così?

Codice: Seleziona tutto

cap = cv.VideoCapture(-1,2)

[alien75]

ecco la risposta con cap = cv.VideoCapture(-1,2):

Codice: Seleziona tutto

output =  [[0 1 0 0]
[0 0 0 0]
[0 1 0 0]
[0 0 0 0]
[0 1 1 0]
[0 1 0 1]]
caricamento wih
caricamento who
Predictions after training:
  image1 [[2.66182146e-09 9.94178502e-01 3.52511715e-16 6.99574262e-14]]
  image2 [[3.90428337e-08 6.03050809e-03 8.78109231e-13 9.62237351e-14]]
  image3 [[3.38047948e-12 9.99974322e-01 9.92514806e-14 5.38169454e-11]]
  image4 [[1.14816566e-03 2.59920198e-08 1.79174668e-16 4.16509779e-11]]
  image5 [[6.66530308e-06 9.97432065e-01 3.20812810e-09 7.86025880e-14]]
  image6 [[1.50948976e-09 9.99516022e-01 1.18324054e-14 6.74659727e-15]]
  image7 [[1.01204201e-07 6.33706324e-01 7.85115852e-12 1.71434986e-10]]
Cannot open camera


[xyz]

cosa dice modificando così?

Codice: Seleziona tutto

cap = cv.VideoCapture(-1,2)

La documentazione non dice nulla sul primo parametro se negativo:
https://docs.opencv.org/4.10.0/d8/dfe/c ... e8cf5fd181

[angus]

Hai ragione

[alien75]

cosa dice modificando così?

Codice: Seleziona tutto

cap = cv.VideoCapture(-1,2)

La documentazione non dice nulla sul primo parametro se negativo:
https://docs.opencv.org/4.10.0/d8/dfe/c ... e8cf5fd181

Ho provato come secondo parametro cv::CAP_DSHOW or cv::CAP_MSMF or cv::CAP_V4L li ho provati col primo parametro a 0.
Con cap = cv.VideoCapture(0,cv.CAP_V4L) ottengo:

Codice: Seleziona tutto

Predictions after training:
  image1 [[3.95007792e-08 9.99999636e-01 9.84281833e-03 1.00000000e+00]]
[ WARN:0@1.857] global cap_v4l.cpp:913 open VIDEOIO(V4L2:/dev/video0): can't open camera by index
[ WARN:0@1.857] global cap.cpp:478 open VIDEOIO(V4L2): backend is generally available but can't be used to capture by index
Cannot open camera


Che dite?
Ho provato pure i primi due parametri sopra ma ottengo il solito messaggio: Cannot open camera.