mdc

import threading

import thread
from twilio.rest import TwilioRestClient
from datetime import datetime
import time
from cv2 import *
from PIL import ImageGrab
import mail2
import sms_send
import cv2.cv as cv
import Tkinter as tk
from email import encoders
from email.mime.base import MIMEBase

import smtplib
from email.mime.multipart import MIMEMultipart

accountSid = 'AC41cefe6de8ff58ed08d88cc9740815a9'
authToken = "3bad46b919771702c608bbd2d8284b44"
twilioClient = TwilioRestClient(accountSid, authToken)
myTwilioNumber = "+19287234071"
destCellPhone = "+919910222142"

class MotionDetectorAdaptative():
    def onChange(self, val):
        self.threshold = val

    def __init__(self, threshold=25, doRecord=True, showWindows=True):

        self.writer = None
        self.font = None
        self.doRecord = doRecord
        self.show = showWindows
        self.frame = None


        self.capture = cv.CaptureFromCAM(0)
        self.frame = cv.QueryFrame(self.capture)
        if doRecord:
            self.Recorder()

        self.gray_frame = cv.CreateImage(cv.GetSize(self.frame), cv.IPL_DEPTH_8U, 1)
        self.average_frame = cv.CreateImage(cv.GetSize(self.frame), cv.IPL_DEPTH_32F, 3)
        self.absdiff_frame = None
        self.previous_frame = None

        self.surface = self.frame.width * self.frame.height
        self.currentsurface = 0
        self.currentcontours = None
        self.threshold = threshold
        self.isRecording = False
        self.trigger_time = 0

        if showWindows:
            cv.NamedWindow("Image")

    def send(self):
        fromaddr = "rmdasec@gmail.com"
        toaddr = "aneeshkhanna10@gmail.com"
        msg = MIMEMultipart()
        msg['From'] = fromaddr
        msg['To'] = toaddr
        msg['Subject'] = "Security Alert"

        filename = "pic.jpg"
        attachment = open('C:\Users\Puzzled\PycharmProjects\untitled\pic.jpg', "rb")
        part = MIMEBase('application', 'octet-stream')
        part.set_payload((attachment).read())
        encoders.encode_base64(part)
        part.add_header('Content-Disposition', "attachment; filename= %s" % filename)
        msg.attach(part)
        server = smtplib.SMTP('smtp.gmail.com', 587)
        server.starttls()
        server.login(fromaddr, "Uditisatraitor")

        text = msg.as_string()
        server.sendmail(fromaddr, toaddr, text)
        server.close()

    def Recorder(self):  # Create the recorder
        codec = cv.CV_FOURCC('I', 'Y', 'U', 'V')
        filename = time.strftime("%m-%d-%H-%M-%S") + '.avi'
        ## self.writer = cv.CreateVideoWriter(datetime.now().strftime("%b-%d_%H_%M_%S") + ".avi", codec, 15,
        #                                   cv.GetSize(self.frame), 1)
        self.writer = cv.CreateVideoWriter(filename, codec, 10.0, cv.GetSize(self.frame), 1)

        self.font = cv.InitFont(cv.CV_FONT_HERSHEY_SIMPLEX, 1, 1, 0, 2, 8)  # Creates a font

    def run(self):
        started = time.time()
        while True:

            currentframe = cv.QueryFrame(self.capture)
            instant = time.time()

            self.processImage(currentframe)

            if not self.isRecording:
                if self.somethingHasMoved():


                    self.trigger_time = instant
                    if instant > started + 10:
                        print "Something is moving !"
                        time.sleep(0.4)
                        ImageGrab.grab().save("pic.jpg", "JPEG")
                        if self.doRecord:
                            self.isRecording = True


                cv.DrawContours(currentframe, self.currentcontours, (0, 0, 255), (0, 255, 0), 1, 2, cv.CV_FILLED)
            else:
                if instant >= self.trigger_time + 10:
                    t = threading.Thread(target=mail2.send())
                    t.start()
                    #myMessage = twilioClient.messages.create(body="Motion has been detected at your premise",from_=myTwilioNumber, to=destCellPhone)
                    print "Stop recording"
                    self.isRecording = False
                else:
                    cv.PutText(currentframe, datetime.now().strftime("%b %d, %H:%M:%S"), (25, 30), self.font,
                               0)
                    cv.WriteFrame(self.writer, currentframe)

            if self.show:
                cv.ShowImage("Image", currentframe)

            c = cv.WaitKey(1) % 0x100
            if c == 27 or c == 10:
                break

    def processImage(self, curframe):

        cv.Smooth(curframe, curframe)

        if not self.absdiff_frame:
            self.absdiff_frame = cv.CloneImage(curframe)
            self.previous_frame = cv.CloneImage(curframe)
            cv.Convert(curframe, self.average_frame)
        else:
            cv.RunningAvg(curframe, self.average_frame, 0.05)

        cv.Convert(self.average_frame, self.previous_frame)

        cv.AbsDiff(curframe, self.previous_frame, self.absdiff_frame)

        cv.CvtColor(self.absdiff_frame, self.gray_frame, cv.CV_RGB2GRAY)
        cv.Threshold(self.gray_frame, self.gray_frame, 50, 255, cv.CV_THRESH_BINARY)

        cv.Dilate(self.gray_frame, self.gray_frame, None, 15)
        cv.Erode(self.gray_frame, self.gray_frame, None, 10)

    def somethingHasMoved(self):

        storage = cv.CreateMemStorage(0)
        contours = cv.FindContours(self.gray_frame, storage, cv.CV_RETR_EXTERNAL, cv.CV_CHAIN_APPROX_SIMPLE)

        self.currentcontours = contours

        while contours:
            self.currentsurface += cv.ContourArea(contours)
            contours = contours.h_next()

        avg = (self.currentsurface * 100) / self.surface
        self.currentsurface = 0

        if avg > 8:

            return True
        else:
            return False


if __name__ == "__main__":

    failure_max = 3
    passwords = [('admin', 'admin'), ('new', 'help')]


    def make_entry(parent, caption, width=None, **options):
        tk.Label(parent, text=caption).pack(side=tk.TOP)
        entry = tk.Entry(parent, **options)
        if width:
            entry.config(width=width)
        entry.pack(side=tk.TOP, padx=10, fill=tk.BOTH)
        return entry


    def enter(event):
        check_password()


    def check_password(failures=[]):
        """ Collect 1's for every failure and quit program in case of failure_max failures """
        print(user.get(), password.get())
        if (user.get(), password.get()) in passwords:
            root.destroy()
            detect = MotionDetectorAdaptative(doRecord=True)
            detect.run()

            print('Logged in')

            return
        failures.append(1)
        if sum(failures) >= failure_max:
            root.destroy()

            raise SystemExit('Unauthorized login attempt')
        else:
            root.title('Try again. Attempt %i/%i' % (sum(failures) + 1, failure_max))


    root = tk.Tk()
    root.geometry('300x160')
    root.title('Enter your information')
    # frame for window margin
    parent = tk.Frame(root, padx=10, pady=10)
    parent.pack(fill=tk.BOTH, expand=True)
    # entrys with not shown text
    user = make_entry(parent, "User name:", 16, show='*')
    password = make_entry(parent, "Password:", 16, show="*")
    # button to attempt to login
    b = tk.Button(parent, borderwidth=4, text="Login", width=10, pady=8, command=check_password)
    b.pack(side=tk.BOTTOM)
    password.bind('<Return>', enter)

    user.focus_set()

    parent.mainloop()