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 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:
            ######The problem area

                t = threading.Thread(target=mail2.send())
                t.start()
                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

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()
        t = threading.Thread(target=mail2.send())

        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()