Ejemplo n.º 1
0
        GPIO.output(21, GPIO.HIGH)


def updateValue(i, value):
    if value[i - 1] == 0:
        GPIO.output(26, GPIO.HIGH)
        GPIO.output(19, GPIO.LOW)
    if value[i - 1] == 1:
        GPIO.output(26, GPIO.LOW)
        GPIO.output(19, GPIO.HIGH)


camera = PiCamera()
camera.resolution = (320, 240)
camera.framerate = 20
rawCapture = PiRGBArray(camera)

hand_cascade = cv2.CascadeClassifier('hand.xml')
startx, starty = -1, -1
endx, endy = -1, -1
counter = 0
diffx, diffy = 1, 1
channel = [16, 20, 21]  # GPIO channel array
value = [0, 0, 0]
i = 1
time.sleep(0.5)

for frame in camera.capture_continuous(rawCapture,
                                       format="bgr",
                                       use_video_port=True):
    # grab the raw NumPy array representing the image, then initialize the timestamp
Ejemplo n.º 2
0
from picamera.array import PiRGBArray
from picamera import PiCamera
import time
from imutils.perspective import four_point_transform
#from imutils import contours
#import imutils

cameraResolution = (320, 240)

# initialize the camera and grab a reference to the raw camera capture
camera = PiCamera()
camera.resolution = cameraResolution
camera.framerate = 32
camera.brightness = 60
camera.rotation = 180
rawCapture = PiRGBArray(camera, size=cameraResolution)

# allow the camera to warmup
time.sleep(2)


def findTrafficSign():
    '''
    This function find blobs with blue color on the image.
    After blobs were found it detects the largest square blob, that must be the sign.
    '''

    # define range HSV for blue color of the traffic sign
    lower_blue = np.array([90, 80, 50])
    upper_blue = np.array([110, 255, 255])
Ejemplo n.º 3
0
def main(name):
    # import the cascades
    face_cascade = cv2.CascadeClassifier('haarcascade_frontalface_default.xml')
    eye_cascade = cv2.CascadeClassifier('haarcascade_eye.xml')

    # load the webcam feed
    #capture = cv2.VideoCapture(0)
    camera = PiCamera()
    camera.resolution = (640, 480)
    camera.framerate = 32
    rawCapture = PiRGBArray(camera, size=(640, 480))

    # counter for picture
    counter = 0

    time.sleep(0.1)

    for frame in camera.capture_continuous(rawCapture,
                                           format="bgr",
                                           use_video_port=True):
        img = frame.array
        gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
        #print capture
        faces = face_cascade.detectMultiScale(img, 1.3,
                                              5)  # array with found faces

        for (x, y, w, h) in faces:
            # draw rectangles
            # img = where to draw
            # next 2 args are start and end points of rectangle
            # next arg is color
            # final arg is line width
            cv2.rectangle(img, (x, y), (x + w, y + h), (255, 0, 0), 2)
            cv2.putText(img, 'Face', (x, y), cv2.FONT_HERSHEY_SIMPLEX, 1,
                        (0, 255, 255), 1, cv2.CV_AA)

            # region of img, dont want to find eyes outside face
            roi_gray = gray[y:y + h, x:x + h]
            #        roi_color = img[y:y+h, x:x+h]

            # only show the face box (row, column of img numpy array to be displayed)
            img = roi_gray
            img = cv2.equalizeHist(img)

        # resize the camera feed
        cv2.imshow('mode 1', img)
        rawCapture.seek(0)
        rawCapture.truncate()
        # 	# resize the camera feed
        # 	cv2.namedWindow('Do not read', cv2.WINDOW_NORMAL)
        #	cv2.imshow('Do not read', img)

        # to save img to file with esc key
        k = cv2.waitKey(30) & 0xff
        if k == 27:
            # unique_filename = uuid.uuid4()
            # unique_filename = str(unique_filename)
            # print "Saving file " +  unique_filename
            im = Image.fromarray(img)
            im = im.resize((92, 112), PIL.Image.ANTIALIAS)
            filename = 'subject' + str(name) + '.' + str(counter) + '.jpeg'
            print 'saving file ' + filename
            im.save('train_faces2/' + filename)
            counter += 1

        if k == 108:  # l
            camera.close()
            cv2.destroyAllWindows()
            return
Ejemplo n.º 4
0

from picamera.array import PiRGBArray
from picamera import PiCamera

image_size = 64
cropped_size = 380
recognition_ratio = 10
res = (640, 480)
fps = 30

# initialize the cam
camera = PiCamera()
camera.resolution = res
camera.framerate = fps
rawCapture = PiRGBArray(camera, size=res)

# allow the camera to warmup
time.sleep(0.1)

# capture frames from the camera
for frame in camera.capture_continuous(rawCapture,
                                       format='bgr',
                                       use_video_port=True):

    # current frame as numpy array
    img = frame.array

    img_gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)

    #    img_resized = resize_img(img_gray, img_size)
GPIO.setup(enB,GPIO.OUT)
p2=GPIO.PWM(enB,1000)

####################motor start
p.start(15)
p2.start(15)
print("\n")
print("working properly by camera.....")
print("\n")    


#camera
camera = picamera.PiCamera()
camera.resolution =(192,108)
camera.framerate = 20
rawCapture = PiRGBArray(camera,size=(192,108))
time.sleep(0.1)


for frame in camera.capture_continuous(rawCapture, format="bgr", use_video_port=True):
    # Display camera input
    image = frame.array
    cv2.imshow('img',image)

    # Create key to break for loop
    key = cv2.waitKey(1) & 0xFF
    
    # convert to grayscale, gaussian blur, and threshold
    gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
    blur = cv2.GaussianBlur(gray,(5,5),0)
    ret,thresh1 = cv2.threshold(blur,100,255,cv2.THRESH_BINARY_INV)
Ejemplo n.º 6
0
import sys

# import the necessary packages for tracking
from imutils import contours
import imutils

from Functions.Blocking import Blocking

Block = Blocking()

# http://picamera.readthedocs.io/en/latest/fov.html
# initialize the Pi camera and grab a reference to the raw camera capture
camera = PiCamera()
camera.resolution = (1648, 928)  #Maximum Resolution with full FOV
camera.framerate = 40  # Maximum Frame Rate with this resolution
rawCapture = PiRGBArray(camera, size=(1648, 928))

# allow the camera to warmup.
time.sleep(0.1)


class UART_Thread(threading.Thread):
    def __init__(self, q_Control_Serial_Write, q_Data_is_Send,
                 q_Control_Uart_Main):
        ''' Constructor. of UART Thread '''
        threading.Thread.__init__(self)

        self.daemon = True
        self.q_Control_Serial_Write = q_Control_Serial_Write
        self.q_Data_is_Send = q_Data_is_Send
        self.q_Control_Uart_Main = q_Control_Uart_Main
Ejemplo n.º 7
0
import imutils
import numpy as np

cascPath = "haarcascade_frontalface_default.xml"
font = cv2.FONT_HERSHEY_SIMPLEX

faceCascade = cv2.CascadeClassifier(cascPath)

casc_smile_path = "haarcascade_smile.xml"
smile_cascade = cv2.CascadeClassifier(casc_smile_path)

# initialize the camera and grab a reference to the raw camera capture
camera = PiCamera()
camera.resolution = (260, 220)
camera.framerate = 40
rawCapture = PiRGBArray(camera, size=(260, 220))

# allow the camera to warmup
time.sleep(0.1)

# capture frames from the camera
for frame in camera.capture_continuous(rawCapture,
                                       format="bgr",
                                       use_video_port=True):
    # grab the raw NumPy array representing the image, then initialize the timestamp
    # and occupied/unoccupied text
    image = frame.array

    gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)

    # Detect faces in the image
Ejemplo n.º 8
0
import imutils
import time
import cv2

# video capturing
count = 0
frame_width = 640
frame_height = 480

# if the video argument is None, then we are reading from webcam
print("Using raspi camera...")
# initialize the camera and grab a reference to the raw camera capture
camera = PiCamera()
camera.resolution = (frame_width, frame_height)
#camera.framerate = 32
rawCapture = PiRGBArray(camera, size=(frame_width, frame_height))
time.sleep(2.0)


# initialize the first frame in the video stream
firstFrame = None


print("[+] Starting security camera...")
for frame in camera.capture_continuous(rawCapture, format="bgr", use_video_port=True):
	rawCapture.truncate(0)

	# grab the current frame and initialize the occupied/unoccupied text
	frame = frame.array
	frame = frame if args.get("video", None) is None else frame[1]
Ejemplo n.º 9
0
from picamera.array import PiRGBArray
from picamera import PiCamera
import math
import time
import cv2
import numpy as np
import os, sys
from LaneDetection import LaneDetection
from CarControl import CarControl
from ObstacleDetection import ObstacleDetection
from ModeView import ModeView

camera = PiCamera()
camera.resolution = (960, 540)
camera.framerate = 15
rawCapture = PiRGBArray(camera, size=(960, 540))
time.sleep(0.1)

GPIO.setmode(GPIO.BCM)
GPIO.setwarnings(False)

laneDetection = LaneDetection()
carControl = CarControl()
modeView = ModeView()
obstacleDetection = ObstacleDetection()

backLeft = [0, 0, 0, 0]
backRight = [0, 0, 0, 0]
vp_slope = [-1, backLeft, backRight]

img2 = np.zeros((540, 960, 3), np.uint8)
Ejemplo n.º 10
0
    x1 = x4 = int(bbox_x1 - mdl_dims / 2)
    #Right - X2
    x2 = x3 = int(bbox_x2 - mdl_dims / 2)
    #Upper - Y1
    y1 = y2 = int(-bbox_y1 + mdl_dims / 2)
    #Lower - Y2
    y3 = y4 = int(-bbox_y2 + mdl_dims / 2)
    z = 1
    bbox_vertices = [[x1, y1, z], [x2, y2, z], [x3, y3, z], [x4, y4, z]]
    return bbox_vertices


with picamera.PiCamera() as camera:
    camera.resolution = (preview_W, preview_H)
    camera.framerate = max_fps
    rgb = PiRGBArray(camera, size=camera.resolution * 3)
    _, width, height, channels = engine.get_input_tensor_shape()
    camera.start_preview(fullscreen=False,
                         layer=0,
                         window=(preview_mid_X, preview_mid_Y, preview_W,
                                 preview_H))
    try:
        while DISPLAY.loop_running():
            stream = io.BytesIO()
            camera.capture(stream, use_video_port=True, format='rgb')
            stream.truncate()
            stream.seek(0)
            input = np.frombuffer(stream.getvalue(), dtype=np.uint8)
            stream.close()
            results = engine.DetectWithInputTensor(input, top_k=max_obj)
            ms = str(int(elapsed_ms * 1000)) + "ms"
Ejemplo n.º 11
0
	def __init__(self,piCamera):
		piCamera.resolution = (304,304)
		piCamera.framerate =32                                        
		self.__piCamera = piCamera
		self.__rawCapture =PiRGBArray(piCamera,size=(304,304))
Ejemplo n.º 12
0
from detect_rgb3 import detect
import serial
import numpy as np
import os

port = '/dev/ttyACM0'
ser = serial.Serial(port, 115200, timeout=2)

X_RESOLUTION = 1280
Y_RESOLUTION = 960

# Initialize the camera and grab a reference to the raw camera capture
camera = PiCamera()
camera.resolution = (X_RESOLUTION, Y_RESOLUTION)
camera.framerate = 5
rawCapture = PiRGBArray(camera, size=(X_RESOLUTION, Y_RESOLUTION))

# Allow camera to warmup
time.sleep(0.1)
i = 0


def speed(left, right):
    motor_control = "m " + str(int(left)) + " " + str(int(right))
    ser.write(motor_control.encode())


test = 0
folder = 'test_' + str(test)
if not os.path.isdir(folder):
    os.mkdir(folder)
Ejemplo n.º 13
0
import numpy as np
import io
from picamera.array import PiRGBArray
from picamera import PiCamera
from PIL import Image as Img
from constants import *

#set up camera and wait small bit of time for it to initialize
camera = PiCamera()
sleep(0.1)

#flip horizontally
camera.hflip = True

#sets up a stream to convert from the camera input to OpenCV object later
stream = PiRGBArray(camera)


#generates the overlay object with appropriate padding
#can specify layer of overlay - defaults to 4
def generate_overlay(img, layer=4):
    print(img.size)
    pad = Img.new('RGB', (
        ((img.size[0] + 31) // 32) * 32,
        ((img.size[1] + 15) // 16) * 16,
    ))
    pad.paste(img, (0, 0))
    o = camera.add_overlay(pad.tobytes(), size=pad.size)
    o.alpha = 32
    o.layer = layer
    return o
Ejemplo n.º 14
0
    return frame


#### Initialize camera and perform object detection ####

# The camera has to be set up and used differently depending on if it's a
# Picamera or USB webcam.

### Picamera ###
if camera_type == 'picamera':
    # Initialize Picamera and grab reference to the raw capture
    camera = PiCamera()
    camera.resolution = (IM_WIDTH, IM_HEIGHT)
    camera.framerate = 10
    rawCapture = PiRGBArray(camera, size=(IM_WIDTH, IM_HEIGHT))
    rawCapture.truncate(0)

    # Continuously capture frames and perform object detection on them
    for frame1 in camera.capture_continuous(rawCapture,
                                            format="bgr",
                                            use_video_port=True):

        t1 = cv2.getTickCount()

        # Acquire frame and expand frame dimensions to have shape: [1, None, None, 3]
        # i.e. a single-column array, where each item in the column has the pixel RGB value
        frame = frame1.array
        frame.setflags(write=1)

        # Pass frame into pet detection function
print("Görüntü alınıyor...")
# Kamera kutuphanesinden bir nesne al ve kamera degiskenine ata
kamera = PiCamera()

# Kayıt/İşlem çözünürlüğü
kamera.resolution = (sbt.KAMERA_COZUNURLUGU[0], sbt.KAMERA_COZUNURLUGU[1])

# Kameranin saniyedeki resim sayisini 50 olarak ayarla
kamera.framerate = 50

# # Kamera kablo baglantisindan dolayi ters durdugu ve goruntu ters gozukecegi icin goruntuyu ters cevir
# kamera.vflip = True

# Resimleri tutmak icin bellekte yer ac
resimBellegi = PiRGBArray(kamera, size=(sbt.KAMERA_COZUNURLUGU[0], sbt.KAMERA_COZUNURLUGU[1]))

# Kameranin hazir olmasi icin biraz bekle
time.sleep(0.1)

print("Video kaydı için hazırlıklar yapılıyor...")
# Video kaydı için
kayitTime = time.strftime("%Y-%m-%d-%H-%M")
fourcc = cv2.VideoWriter_fourcc(*'XVID')
temizKayit = cv2.VideoWriter('./Medya/Kayitlar/' + kayitTime + 'temizKayit.avi', fourcc, 10.0, (sbt.KAMERA_COZUNURLUGU[0], sbt.KAMERA_COZUNURLUGU[1]))
duvarKayit = cv2.VideoWriter('./Medya/Kayitlar/' + kayitTime + 'duvarKayit.avi', fourcc, 10.0, (sbt.CV_COZUNURLUGU[0], sbt.CV_COZUNURLUGU[1]))
gemiKayit = cv2.VideoWriter('./Medya/Kayitlar/' + kayitTime + 'gemiKayit.avi', fourcc, 10.0, (sbt.CV_COZUNURLUGU[0], sbt.CV_COZUNURLUGU[1]))
kapiKayit = cv2.VideoWriter('./Medya/Kayitlar/' + kayitTime + 'kapiKayit.avi', fourcc, 10.0, (sbt.CV_COZUNURLUGU[0], sbt.CV_COZUNURLUGU[1]))
surKayit = cv2.VideoWriter('./Medya/Kayitlar/' + kayitTime + 'surKayit.avi', fourcc, 10.0, (sbt.CV_COZUNURLUGU[0], sbt.CV_COZUNURLUGU[1]))

print("Görevlere hazırlanılıyor...")
Ejemplo n.º 16
0
def map(x, in_min, in_max, out_min, out_max):
    maps = ((x - in_max) * (out_max - out_min) / (in_max - in_min) + out_min +
            10)
    return maps


kp = 100
servo1 = 21
servo2 = 20
deltadt = 0.1
dt1 = 4
dt2 = 7
rp.setmode(rp.BCM)
rp.setwarnings(False)
rp.setup(servo1, rp.OUT)
rp.setup(servo2, rp.OUT)
pwm1 = rp.PWM(servo1, 50)
pwm2 = rp.PWM(servo2, 50)
pwm1.start(4)
pwm2.start(2)

webcam = PiCamera()
webcam.resolution = (640, 480)
webcam.framerate = 90
video = PiRGBArray(webcam, size=(640, 480))
pwm2.ChangeDutyCycle(2)
for i in range(2, 12, 1):
    #pwm1.ChangeDutyCycle(dty)
    pwm2.ChangeDutyCycle(i)
    sleep(1)
Ejemplo n.º 17
0
fps = 30
logOffset = 3  # Skip this number of datapoints while logging

# Create MP4 video file at 720p 30fps
fourcc = cv2.VideoWriter_fourcc(*'mp4v')
out = cv2.VideoWriter('output.mp4', fourcc, fps, resolution)

# Create file to log data
f = open('PiCameraTestData.txt', 'a')

# Initialize the Raspberry Pi camera
camera = PiCamera()
camera.resolution = (1280, 720)
camera.framerate = 30

rawCapture = PiRGBArray(camera, size=(1280, 720))

minHSV = np.array([40, 20, 25])
maxHSV = np.array([100, 180, 185])

# Framerate cumulative moving average
cmaFramerate = 0

# Number of desired datapoints to log
desiredDataPoints = 200
i = -logOffset

start = 0
stop = 0

for frame in camera.capture_continuous(rawCapture,
Ejemplo n.º 18
0
import numpy as np
import tensorflow as tf
import time

model = tf.keras.models.load_model('digits_model.h5')
SZ = 28
frame_width = 300
frame_height = 300
frame_resolution = [frame_width, frame_height]
frame_rate = 16
margin = 30
# initialize the camera and grab a reference to the raw camera capture
camera = PiCamera()
camera.resolution = frame_resolution
camera.framerate = frame_rate
rawCapture = PiRGBArray(camera, size=(frame_resolution))
# allow the camera to warmup
time.sleep(0.1)

# capture frames from the camera
for frame in camera.capture_continuous(rawCapture,
                                       format="bgr",
                                       use_video_port=True):
    # grab the raw NumPy array representing the image
    image = frame.array
    # hsv transform - value = gray image
    hsv = cv2.cvtColor(image, cv2.COLOR_BGR2HSV)
    hue, saturation, value = cv2.split(hsv)

    # kernel to use for morphological operations
    kernel = cv2.getStructuringElement(cv2.MORPH_RECT, (3, 3))
Ejemplo n.º 19
0
# client
warnings.filterwarnings("ignore")
conf = json.load(open(args["conf"]))
client = None

# check to see if the Dropbox should be used
if conf["use_dropbox"]:
	# connect to dropbox and start the session authorization process
	client = dropbox.Dropbox(conf["dropbox_access_token"])
	print("[SUCCESS] dropbox account linked")

# initialize the camera and grab a reference to the raw camera capture
camera = PiCamera()
camera.resolution = tuple(conf["resolution"])
camera.framerate = conf["fps"]
rawCapture = PiRGBArray(camera, size=tuple(conf["resolution"]))

# allow the camera to warmup, then initialize the average frame, last
# uploaded timestamp, and frame motion counter
print("[INFO] warming up...")
time.sleep(conf["camera_warmup_time"])
avg = None
lastUploaded = datetime.datetime.now()
motionCounter = 0

# capture frames from the camera
for f in camera.capture_continuous(rawCapture, format="bgr", use_video_port=True):
	# grab the raw NumPy array representing the image and initialize
	# the timestamp and occupied/unoccupied text
	frame = f.array
	timestamp = datetime.datetime.now()
Ejemplo n.º 20
0
import cv2
import numpy
# import the necessary packages
from picamera.array import PiRGBArray
from picamera import PiCamera
import time

print("123")
#initialise the camera and grab a reference to raw camera capture
camera = PiCamera()
print("123")
camera.resolution = (800, 600)
rawCapture = PiRGBArray(camera, size=(800, 600))
time.sleep(0.1)
print(123)
while (1):
    print("123")

    # allow the camera to warmup
    time.sleep(0.1)
    print("456")
    # grab an image from the camera
    camera.capture(rawCapture, format="bgr")
    camera.capture("foo.jpg")
    frame = rawCapture.array

    # display the image on screen and wait for a keypress
    cv2.imshow("Image", frame)
    cv2.waitKey(8000)
    cv2.destroyAllWindows()
camera.close()
Ejemplo n.º 21
0
from picamera import PiCamera
import cv2
import time
import numpy
import stepper

RES_CONST = 1

face_cascade = cv2.CascadeClassifier(
    "/usr/local/lib/python3.7/dist-packages/cv2/data/haarcascade_frontalface_default.xml"
)

camera = PiCamera()
camera.resolution = (640 * RES_CONST, 480 * RES_CONST)
camera.framerate = 50
rawCapture = PiRGBArray(camera, size=(640 * RES_CONST, 480 * RES_CONST))

time.sleep(0.1)

for image in camera.capture_continuous(rawCapture,
                                       format="bgr",
                                       use_video_port=True):
    frame = image.array

    #frame = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
    faces = face_cascade.detectMultiScale(frame,
                                          scaleFactor=1.25,
                                          minNeighbors=5)

    if len(faces) > 0:
Ejemplo n.º 22
0
        
    # Pic Properties
    picWidth = 640
    picHeight = 480
    framerate = 32

    # Camera FOV
    hfov = 62.2
    vfov = 48.8
    
    # initialize the camera and grab a reference to the raw camera capture
    camera = PiCamera()
    camera.resolution = (picWidth, picHeight)
    camera.framerate = framerate
    camera.vflip = True
    rawCapture = PiRGBArray(camera, size=(picWidth, picHeight))

    # allow the camera to warmup
    time.sleep(0.1)

    # capture frames from the camera
    for f in camera.capture_continuous(rawCapture, format="bgr", use_video_port=True):
        # grab the raw NumPy array representing the image, then initialize the timestamp
        # and occupied/unoccupied text
        frame = f.array
        
        # Find the lightSources in the unwarped image, and label them
        lightSources = findLightSources(frame, 230)     # Threshold of 200 (arbitrary, needs experimentation)
        lightLoc = []
        angles = []
        trueAngles = []
Ejemplo n.º 23
0
widths = 440
heigths = 280

resX = 6
resY = 6
count = 0
imc = 0

hue = 0
sat = 0
val = 0
camera = PiCamera()
camera.resolution = (widths, heigths)
camera.framerate = 32
camera.hflip = True
rawCapture = PiRGBArray(camera, size=(widths, heigths))

time.sleep(0.1)
def closest_colour(requested_colour):
    min_colours = {}
    for key, name in webcolors.css3_hex_to_names.items():
        r_c, g_c, b_c = webcolors.hex_to_rgb(key)
        rd = (r_c - requested_colour[0]) ** 2
        gd = (g_c - requested_colour[1]) ** 2
        bd = (b_c - requested_colour[2]) ** 2
        min_colours[(rd + gd + bd)] = name
    return min_colours[min(min_colours.keys())]

def dec_conv(x):
    return format(x, '03d')
Ejemplo n.º 24
0
def main_code():
    RELAY = 17
    gpio.setmode(gpio.BCM)
    gpio.setup(RELAY, gpio.OUT, initial=gpio.LOW)
    camera = PiCamera()
    camera.resolution = (640, 480)
    camera.framerate = 32
    rawCapture = PiRGBArray(camera, size=(640, 480))

    faceCascade = cv2.CascadeClassifier("haarcascade_frontalface_default.xml")
    eyesCascade = cv2.CascadeClassifier("haarcascade_eye_tree_eyeglasses.xml")

    time.sleep(0.1)
    c = 30
    for frame in camera.capture_continuous(rawCapture,
                                           format="bgr",
                                           use_video_port=True):
        image = frame.array

        gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
        faces = faceCascade.detectMultiScale(gray,
                                             scaleFactor=1.1,
                                             minNeighbors=5,
                                             minSize=(50, 50))
        for (x, y, w, h) in faces:
            cv2.rectangle(image, (x, y), (x + w, y + h), (0, 255, 0), 2)
            roi_gray = gray[y:y + h, x:x + w]
            roi_color = image[y:y + h, x:x + w]
            eyes = eyesCascade.detectMultiScale(roi_gray)
            for (ex, ey, ew, eh) in eyes:
                #print(eyes)
                cv2.rectangle(roi_color, (ex, ey), (ex + ew, ey + eh),
                              (100, 255, 255), 2)

            if len(faces) >= 1 and len(eyes) >= 2:
                # cv2.putText(image, 'WARNING!', (10, 500), cv2.FONT_HERSHEY_SIMPLEX, 4, (255, 255, 255), 2)
                c += 1
                if c >= 30:
                    c = 30
                    print("off ", c)
                    gpio.output(RELAY, False)
            else:
                gpio.output(RELAY, True)
                c -= 1
                if c <= 0:
                    c = 0
                    print("on ", c)
                    gpio.output(RELAY, True)
                    location = get_location(
                        "https://parna-tech-gvp.000webhostapp.com/get_text.php"
                    )
                    mess = "DRIVER IS SLEEPING AT POSITION $/maps.google.com/?q=" + str(
                        location[0]) + "," + str(location[1])
                    resp, code = sendSMS(
                        'eUsxYafnBc0-FVAQyyMIBL4sXtGxz7WsFppmfolVqN',
                        '919052687894', 'TXTLCL', mess)
                    print(resp)
        #cv2.imshow("Frame", image)
        key = cv2.waitKey(1) & 0xFF
        rawCapture.truncate(0)

        if key == ord("q"):
            break

    gpio.output(RELAY, False)
    gpio.cleanup()

    cv2.destroyAllWindows()