Esempio n. 1
0
def main():
    cur_user = users.add_user()
    while True:
        create = Create(shared, cur_user)
        edit = Edit(shared, cur_user)
        read = Read(shared, cur_user)

        print(f"\nCurrent User: {cur_user}")
        choice = main_menu_funct()

        if choice == 0:
            break
        if choice == 1:
            create.create()
        if choice == 2:
            read.read_by_date()
        if choice == 3:
            read.read_all()
        if choice == 4:
            edit.modify()
        if choice == 5:
            edit.remove()
        if choice == 6:
            cur_user = users.add_user()
        if choice == 7:
            cur_user = users.load_user()
        if choice == 8:
            save()
Esempio n. 2
0
def main(_):

    from create import Create
    create = Create()
    create.create()

    from train import NLKExtract
    train = NLKExtract()
    train.train()
Esempio n. 3
0
    def main(self):
        c = Create(.5)
        p1 = Process(1.0, 2)
        p21 = Process(4.0, 1)
        p22 = Process(3.0, 2)
        p3 = Process(1.2, 1)
        print('id0 = {} id1= {} '.format(c.getId(), p1.getId()))
        c.setNextElement(p1)
        p1.setMaxqueue(5)
        p21.setMaxqueue(3)
        p22.setMaxqueue(2)
        p3.setMaxqueue(2)
        c.setName('CREATOR')
        p1.setName('PROCESSOR1')
        p21.setName('PROCESSOR21')
        p22.setName('PROCESSOR22')
        p3.setName('PROCESSOR3')
        c.setDistribution('exp')
        p1.setDistribution('exp')
        p21.setDistribution('exp')
        p22.setDistribution('exp')
        p3.setDistribution('exp')

        p1.setNextElements([p21, p22])
        p21.setNextElements([p3])
        p22.setNextElements([p3])

        elementsList = [c, p1, p21, p22, p3]
        model = Model(elementsList)
        model.simulate(1000.0)
Esempio n. 4
0
    def createElements(self, count):
        c = Create(2)
        c.name = 'CREATOR'
        elementsList = [c]
        for i in range(1, count):
            e = Process(random.choice(self.delays), 1)
            e.maxQueue = 124325435
            e.name = 'PROCESSOR {}'.format(i)
            c.nextElements.append(e)
            elementsList.append(e)

        return elementsList
Esempio n. 5
0
    def mainMenu():
        print('''Main Menu
--------------------------------------------
  1. View Data
  2. Create Data
  3. Update Data
--------------------------------------------''')

        mainMenuInput = input("Input choice(q to Quit): ")
        mainMenuInput = mainMenuInput.lower()
        if mainMenuInput == "1":
            viewMenuOutput = View.viewMenu()
            if viewMenuOutput == "b":
                ProgramUI.mainMenu()
            elif viewMenuOutput == "q":
                return viewMenuOutput
        elif mainMenuInput == "2":
            createMenuOutput = Create.createMenu()
            if createMenuOutput == "b":
                ProgramUI.mainMenu()
            elif createMenuOutput == "q":
                return createMenuOutput
        elif mainMenuInput == "3":
            updateMenuOutput = Update.updateMenu()
            if updateMenuOutput == "b":
                ProgramUI.mainMenu()
            elif updateMenuOutput == "q":
                return updateMenuOutput
        elif mainMenuInput == "q":
            return mainMenuInput
        else:
            print("Wrong input, try again")
            ProgramUI.mainMenu()
Esempio n. 6
0
    def main(self):
        c = Create(15)
        c.setDistribution('exp')
        c.setName('creator')

        p0 = Doctor(0, 0, 2)
        p0.setName('doctors')
        p0.setDistribution('exp')

        p1 = Process(3, 8, 3)
        p1.setName('chambers')
        p1.setDistribution('unif')
        #p1.setDistribution('exp')

        p2 = Process(3, 4.5, 1)
        p2.setName('registration')
        #p2.set_distribution('erlang')
        p2.setDistribution('exp')
        #p2.maxQueue = 2

        p3 = Labs(2, 4, 2)
        p3.setName('lab')
        p3.setDistribution('exp')
        #p3.set_distribution('erlang')

        #p0.chambers = p1
        #p0.registration = p2
        c.nextElement = p0
        p0.setNextElements([p1, p2])
        p2.setNextElements([p3])
        p3.setNextElements([p0])

        elementsList = [c, p0, p1, p2, p3]
        model = Model(elementsList)
        model.simulate(10000.0)
def main():
    print('Available Options: C=Create, R=Read, U=Update, D=Delete ')
    choice = input('Choose your option = ')

    if choice == 'C':
        createObj=Create()
        createObj.func_CreateData()
    elif choice == 'R':
        readObj =  Read()
        readObj.func_ReadData()
    elif choice == 'U':
        updateObj = Update()
        updateObj.func_UpdateData()
    elif choice == 'D':
        deleteObj = Delete()
        deleteObj.func_DeleteData()
    else:
        print('Wrong choice, You are going exist.')
Esempio n. 8
0
def createdriver():
    try:
        if request.method == "GET":
            logging.debug("incoming GET request: " + str(dict(request.args)))
            driver_number = request.args["number"]
            response = Create.check_driver_repetition(driver_number)
            logging.debug("createdriver returned: " + str(response))
            return response
        if request.method == "POST":
            logging.debug("incoming POST request: " + str(request.form))
            driver_name = request.form["name"]
            driver_number = request.form["number"]
            response = Create.create_user(driver_number, driver_name)
            logging.debug("createuser returned:\n" + str(response))
            return response
    except RuntimeError as e:
        logging.critical("failure in v1/createuser with error: " + str(e))
        return default_error
def main():
    while 1:
        print(
            'Available Options: C=Create, R=Read, U=Update, D=Delete, E=Exit ')
        choice = input('Choose your option = ')

        if choice == 'C':
            createObj = Create()
            createObj.func_CreateData()
        elif choice == 'R':
            readObj = Read()
            readObj.func_ReadData()
        elif choice == 'U':
            updateObj = Update()
            updateObj.func_UpdateData()
        elif choice == 'D':
            deleteObj = Delete()
            deleteObj.func_DeleteData()
        elif choice == 'E':
            break
Esempio n. 10
0
def createuser():
    try:
        if request.method == "GET":
            logging.info("  Incoming request:\n" + str(request.args))
            user_number = request.args["number"]
            response = Create.check_user_repetition(user_number)
            logging.info("  Response:\n" + str(response))
            with app.app_context():
                response = make_response(response)
            return response
        if request.method == "POST":
            logging.info("  Incoming request:\n" + str(request.args))
            user_name = request.form["name"]
            user_number = request.form["number"]
            response = Create.create_user(user_number, user_name)
            logging.info("  Response:\n" + str(response))
            with app.app_context():
                response = make_response(response)
            return response
    except RuntimeError as e:
        logging.critical("  Failure in v1/createuser with error: " + str(e))
        return default_error
Esempio n. 11
0
def updatedriver():
    try:
        if request.method == "POST":
            number = request.form["number"]
            name = request.form["name"]
            photo_link = request.args["profile_pic_link"]
            response = Create.update_user(number, name, photo_link)
            logging.debug("Responded to update driver request")
            return response
    except RuntimeError as e:
        logging.critical("failure in v1/updateriver with error: " + str(e) +
                         " |for request: " + str(dict(request.args)))
        return default_error
Esempio n. 12
0
    def __init__(self):
        super().__init__()
        self.__create = Create(self)
        self.btn_restart = QPushButton('Start', self)
        self.new_game = QPushButton('New game', self)
        self.set_chip = QPushButton('Set chip', self)
        self.btn_show_statistic = QPushButton('Show statistic', self)
        self.le = QLineEdit(self)
        self.text = QTextEdit(self)
        self.set_player1 = QComboBox(self)
        self.set_player2 = QComboBox(self)
        self.init_comboBox()

        self.init_base_ui()
Esempio n. 13
0
    def __init__(self):
        pygame.init()

        # Setting variables
        self.pathToProjects = ""

        # Getting launcher settings
        self.getLauncherSettings()

        # Launcher window
        self.window = pygame.display.set_mode(SIZE)
        pygame.display.set_caption("Launcher")

        # Launcher icon
        launcherIcon = loadImage("launcher/icon.png")
        pygame.display.set_icon(launcherIcon)

        # Current folder
        self.currentFolder = os.getcwd()

        # Boolean variables
        self.running = True

        # Clock
        self.clock = pygame.time.Clock()

        # Launcher
        self.launcher = Launcher()

        # Create
        self.create = Create(self.pathToProjects)

        # Path
        self.path = ""

        # Gameloop
        self.loop()
Esempio n. 14
0
def updateuser():
    try:
        if request.method == "POST":
            logging.info("  Incoming request:\n" + str(request.form))
            number = request.form["number"]
            name = request.form["name"]
            photo_link = request.form["profile_pic_link"]
            response = Create.update_user(number, name, photo_link)
            logging.info("  Response:\n" + str(response))
            with app.app_context():
                response = make_response(response)
            return response
    except RuntimeError as e:
        logging.critical("  Failure in v1/updateuser with error: " + str(e))
        return default_error
Esempio n. 15
0
    def main(self):
        c = Create(2)
        p1 = Process(.6, 1)
        p2 = Process(.3, 1)
        p3 = Process(.4, 1)
        p4 = Process(.1, 2)

        print('id0 = {} id1= {} '.format(c.getId(), p1.getId()))
        c.setNextElement(p1)
        c.setName('CREATOR')
        p1.setName('PROCESSOR1')
        p2.setName('PROCESSOR2')
        p3.setName('PROCESSOR3')
        p4.setName('PROCESSOR4')
        c.setDistribution('exp')
        p1.setDistribution('exp')
        p2.setDistribution('exp')
        p3.setDistribution('exp')
        p4.setDistribution('exp')

        p1.setNextElements([p2, p3, p4, None])
        p1.elementsProbabilities = [0.15, 0.13, 0.3, 0.42]

        p2.setNextElements([p1])
        p3.setNextElements([p1])
        p4.setNextElements([p1])

        elementsList = [c, p1, p2, p3, p4]
        model = Model(elementsList)
        model.simulate(1000000.0)

        res = model.returnResult()
        res['theoretical_mean_queue'] = [1.786, 0.003, 0.004, 0.00001]
        res['theoretical_workload'] = [0.714, 0.054, 0.062, 0.036]
        res['queue_accuracy'] = 100 * (
            abs(res.eval('mean - theoretical_mean_queue')) /
            res['theoretical_mean_queue'])
        res['workload_accuracy'] = 100 * (
            abs(res.eval('workload - theoretical_workload')) /
            res['theoretical_workload'])
        print(res)
Esempio n. 16
0
    def setUp(self):
        self.sideFrame = Frame(self.root, width=200, height=500, bg="pink")
        self.topFrame = Frame(self.root, width=600, height=25, bg="blue")
        self.bottomFrame = Frame(self.root, width=600, height=25, bg="brown")
        self.homeFrame = Frame(self.root, width=600, height=450)
        self.createFrame = Frame(self.root, width=600, height=450)

        self.sideFrame.grid(row=0, column=0, sticky="w")
        self.topFrame.grid(row=0, column=1, sticky="n")
        self.bottomFrame.grid(row=0, column=1, sticky="s")
        self.homeFrame.grid(row=0, column=1)
        self.createFrame.grid(row=0, column=1)
        self.panels = {"home": self.homeFrame, "create": self.createFrame}
        home = Home(self.homeFrame, self.panels)
        create = Create(self.createFrame, self.panels)

        self.panels["home"].tkraise()
Esempio n. 17
0
    def main(self):
        p11 = Process(.3, .3, 1)
        p12 = Process(.3, .3, 1)
        p11.otherProcess = p12
        p12.otherProcess = p11
        c = Create(.5)
        c.setNextElements([p11, p12])
        p11.setMaxqueue(3)
        p12.setMaxqueue(3)
        p11.state = 1
        p12.state = 1
        c.tnext = 0.1
        p11.queue = 2
        p12.queue = 2
        c.setName('CREATOR')
        p11.setName('PROCESSOR21')
        p12.setName('PROCESSOR22')
        c.setDistribution('exp')
        p11.setDistribution('exp')
        p12.setDistribution('exp')

        elementsList = [c, p11, p12]
        model = Model(elementsList)
        model.simulate(10000.0)
Esempio n. 18
0
 def verify_otp(number, otp):
     conn                        = None
     try:
         conn, cur               = Sql.get_connection()
         logging.debug("Connection and cursor received")
         sql_query               = "select session_id from driver_otp where number = " + str(number)
         cur.execute(sql_query)
         data                    = cur.fetchone()
         session_id              = str(data[0])
         print(session_id)
         response                = requests.get("https://2factor.in/API/V1/" + str(config.api_key_2factor) + "/SMS/VERIFY/" + str(session_id)+ "/" + str(otp))
         response                = dict(response.json())
         if response["Status"] == "Success" and response["Details"] == "OTP Matched" :
             sql_query           = "update driver_otp set otp_verified = 1 where number = " + str(number)
             cur.execute(sql_query)
             conn.commit()
             response            = Create.check_user_repetition(number)
             if "present" in response:
                 if response["present"]  == 1:
                     result              = Response.make_response(200, "OTP matched", "OTP matched successfully", action = "login", match = 1)
                 if response["present"]  == 0:
                     result              = Response.make_response(200, "OTP matched", "OTP matched successfully", action = "signUp", match = 1)
                 logging.debug("OTP verified successfully")
                 conn.close()
                 return result
             else:
                 conn.close()
                 error               = Response.make_response(500, "System failure", "Oops something went wrong !")
                 return error
         else:
             logging.debug("OTP could not be verified")
             error               = Response.make_response(200, "OTP mismatched", "OTP does not match", match = 0)
             conn.close()
             return error
     except Exception as e:
         if conn is not None:
             conn.close()
         logging.error("Error in verify_otp: " + str(e))
         error               = Response.make_response(500, "System failure", "Oops something went wrong !")
         return error
Esempio n. 19
0
    def __init__(self, video_src, port, baud):
        self.cam = cv2.VideoCapture(video_src)
        ret, self.frame = self.cam.read()
        cv2.namedWindow('Create Tracker')
        cv2.setMouseCallback('Create Tracker', self.mouse)

        self.selection = None
        self.drag_start = None
        self.tracking_state = 0
        self.dest = None
        self.state = 'Servo: Pivot'
        self.pivot_dir = 'l' # default pivot direction left
        self.move_dir = 'f' # default move direction forward
        if not port:
            port = '/dev/ttyUSB0'
        if not baud:
            baud = 115200
        self.robot = Create(port, baud)
        self.robot.sendCommandASCII('128')
        self.robot.sendCommandASCII('131')
        self.prev_angle = 0
        self.prev_dist = 0
        self.counter = 0
Esempio n. 20
0
def setup_video(device='/dev/video7'):
    set_resolution = subprocess.Popen(
        "v4l2-ctl -v width=160,height=120".split())
    set_resolution.wait()
    return subprocess.Popen([
        'cvlc', '--no-audio',
        'v4l2://' + device + ':width=160:height=120:fps=5:chroma=mjpg',
        '--sout=#standard{access=http,mux=mpjpeg,dst=0.0.0.0:8080}',
        '--sout-http-mime=multipart/x-mixed-replace;boundary=--7b3cc56e5f51db803f790dad720ed50a'
    ])


controller = None
last_control = time()
c = Create('/dev/ttyO0', FULL_MODE)
drive_speed = 0
turn_speed = 0


class CreateHandler(BaseHTTPRequestHandler):
    def do_GET(self):
        global controller, last_control
        request_client = self.client_address[0]
        try:
            request, commands = self.path.split("?")
        except:
            if self.path == '/jquery.js':
                self.set_mime_type('text/javascript')
                self.send_file('jquery.js')
                return
Esempio n. 21
0
        r.go(fwd_velocity)
        r.waitDistance(fwd_distance)
        r.stop()
        sleep(.25)
    in_file.close()


def via(r, filename):
    """Drive the robot according to data on each line in file.

    Keyword arguments:
    r -- robot object and serial connection
    filename -- data file with waypoints

    Returns: nothing, moves to points in filename.

    """
    pass
    #sense distance
    #waitAngle
    #waitDistance
    #sleep(long)
    #shutdown

if __name__ == '__main__':
    r = Create(SERIAL_PORT)
    filename = input("Please enter name of data file: ")
    load_numbers(r, filename)
    sleep(50)
    r.shutdown()
Esempio n. 22
0
from create import Create
from read import Read
from update import Update
from delete import Delete
from raw_crud import connection_to_server

conn = connection_to_server()  #Default localhost i połączenie z bazą TheShips

if conn:
    while True:
        print('c=Create, r=Read, u=Update, d=Delete, anything else=Exit ')
        choice = input('What do you want to do? Choose one option:  ')

        if choice == 'c':
            create1 = Create()
            create1.insert_row(conn)
        elif choice == 'r':
            read1 = Read()
            read1.display_table(conn)
        elif choice == 'u':
            update1 = Update()
            update1.update_rows(conn)
        elif choice == 'd':
            delete1 = Delete()
            delete1.delete_rows(conn)
        else:
            print('Bye :)')
            break

else:
    print('Failed to connect to database')
Esempio n. 23
0
class CreateTracker(object):
    def __init__(self, video_src, port, baud):
        self.cam = cv2.VideoCapture(video_src)
        ret, self.frame = self.cam.read()
        cv2.namedWindow('Create Tracker')
        cv2.setMouseCallback('Create Tracker', self.mouse)

        self.selection = None
        self.drag_start = None
        self.tracking_state = 0
        self.dest = None
        self.state = 'Servo: Pivot'
        self.pivot_dir = 'l' # default pivot direction left
        self.move_dir = 'f' # default move direction forward
        if not port:
            port = '/dev/ttyUSB0'
        if not baud:
            baud = 115200
        self.robot = Create(port, baud)
        self.robot.sendCommandASCII('128')
        self.robot.sendCommandASCII('131')
        self.prev_angle = 0
        self.prev_dist = 0
        self.counter = 0

    def mouse(self, event, x, y, flags, param):
        '''
        Actions on mouse click.
        '''
        if event == cv2.EVENT_LBUTTONDOWN:
            self.drag_start = (x, y)
            if self.tracking_state == 1:
                self.dest = (x,y)
                self.state = 'Servo: Pivot'
            else:
                self.tracking_state = 0

        elif event == cv2.EVENT_LBUTTONUP:
            h, w = self.frame.shape[:2]
            xo, yo = self.drag_start
            x0, y0 = np.maximum(0, np.minimum([xo, yo], [x, y]))
            x1, y1 = np.minimum([w, h], np.maximum([xo, yo], [x, y]))
            self.selection = None
            if x1-x0 > 0 and y1-y0 > 0:
                self.selection = (x0, y0, x1, y1)
                self.tracking_state = 1

    def dist(self, pt1, pt2):
        '''
        Calculate distance between two points.
        '''
        return ((pt1[0] - pt2[0])**2 + (pt1[1] - pt2[1])**2)**0.5

    def doAction(self, diff, center):
        '''
        Handle actions and state changes
        '''
        # Test default direction
        if self.state == 'Servo: Pivot':
            self.prev_angle = diff
            self.robot.sendCommand(self.pivot_dir)
            self.state = 'Pivot: Wait'

        # Wait 4 cycles
        elif self.state == 'Pivot: Wait':
            self.counter += 1
            if self.counter == 4:
                self.counter = 0
                self.robot.sendCommand('s')
                self.state = 'Determine Direction'

        # If default pivot direction wrong, change direction
        elif self.state == 'Determine Direction':
            if (
                    (abs(diff) > abs(self.prev_angle) and abs(self.prev_angle) < 90) or 
                    (abs(diff) < abs(self.prev_angle) and abs(self.prev_angle) > 90)  
                ):
                if self.pivot_dir == 'l':
                    self.pivot_dir = 'r'
                else:
                    self.pivot_dir = 'l'
            self.robot.sendCommand(self.pivot_dir)
            self.state = 'Turning'

        # Continue turning until angle between lines is small
        elif self.state == 'Turning':
            d = self.dist(center, self.dest)
            if d < 30:
                self.state = 'Done'
                self.robot.sendCommand('s')
            if abs(diff) < 5 or abs(diff) > 175:
                self.state = 'Correct'
                self.robot.sendCommand('s')

        # Correc the angle slightly
        elif self.state == 'Correct':
            if self.pivot_dir == 'l':
                self.robot.sendCommand('r')
            else:
                self.robot.sendCommand('l')
            self.state = 'Correct: Wait'

        # Wait 3 cycles
        elif self.state == 'Correct: Wait':
            self.counter += 1
            if self.counter == 3:
                self.counter = 0
                self.robot.sendCommand('s')
                self.state = 'Servo: Move'

        # Test default movement direction
        elif self.state == 'Servo: Move':
            self.prev_dist = self.dist(center, self.dest)
            self.robot.sendCommand(self.move_dir)
            self.state = 'Move: Wait'

        # Wait 6 cycles -- Movement direction is more critical, so wait longer
        elif self.state == 'Move: Wait':
            self.counter += 1
            if self.counter == 6:
                self.counter = 0
                self.robot.sendCommand('s')
                self.state = 'Determine Motion'

        # If movement direction wrong, change direction
        elif self.state == 'Determine Motion':
            d = self.dist(center, self.dest)
            if d > self.prev_dist:
                if self.move_dir == 'f':
                    self.move_dir = 'b'
                else:
                    self.move_dir = 'f'
            self.robot.sendCommand(self.move_dir)
            self.state = 'Moving'

        # Move until distance is small or if angle becomes too large
        elif self.state == 'Moving':
            if abs(diff) > 45 and abs(diff) < 135:
                self.state = 'Servo: Pivot'
                self.robot.sendCommand('s')
            d = self.dist(center, self.dest)
            if d < 30:
                self.robot.sendCommand('s')
                self.state = 'Done'


    def run(self):
        '''
        Main loop.
        '''

        while True:

            # read image from camera
            ret, self.frame = self.cam.read()
            vis = self.frame.copy()
            hsv = cv2.cvtColor(self.frame, cv2.COLOR_BGR2HSV)

            # create mask
            mask = cv2.inRange(hsv, np.array((0., 60., 32.)), np.array((180., 255., 255.)))

            # track the selected object
            if self.selection:
                x0, y0, x1, y1 = self.selection
                self.track_window = (x0, y0, x1-x0, y1-y0)
                hsv_roi = hsv[y0:y1, x0:x1]
                mask_roi = mask[y0:y1, x0:x1]
                hist = cv2.calcHist( [hsv_roi], [0], mask_roi, [16], [0, 180] )
                cv2.normalize(hist, hist, 0, 255, cv2.NORM_MINMAX);
                self.hist = hist.reshape(-1)

                vis_roi = vis[y0:y1, x0:x1]
                cv2.bitwise_not(vis_roi, vis_roi)
                vis[mask == 0] = 0

            if self.tracking_state == 1:
                self.selection = None
                prob = cv2.calcBackProject([hsv], [0], self.hist, [0, 180], 1)
                prob &= mask
                term_crit = ( cv2.TERM_CRITERIA_EPS | cv2.TERM_CRITERIA_COUNT, 10, 1 )
                track_box, self.track_window = cv2.CamShift(prob, self.track_window, term_crit)

                # show center of ellipse
                center = (int(track_box[0][0]), int(track_box[0][1]))
                cv2.circle(vis, center, 8, (0,255,0), -1)

                # show destination
                cv2.circle(vis, self.dest, 8, (0,0,255), -1) # red circle at destination

                # show direction line
                if self.dest:
                    cv2.line(vis, self.dest, center, (255,0,0), 2) # blue line to destination

                # calculate orientation
                or_angle = track_box[2]

                # show orientation axis
                pt2_x = int(round(center[0] + 100 * math.sin(-math.pi/180 * or_angle), 0))
                pt2_y = int(round(center[1] + 100 * math.cos(-math.pi/180 * or_angle), 0))
                pt2 = (pt2_x, pt2_y)

                try:
                    cv2.line(vis, center, pt2, (0, 255, 0), 2) # green line through orientation axis
                except:
                    pt2 = (center[0], center[1] + 30)
                    cv2.line(vis, center, pt2, (0, 255, 0), 2) 
                    print(center)

                try:
                    cv2.ellipse(vis, track_box, (0, 255, 0), 2) # green ellipse around selection
                except:
                    print(track_box)


                # Arduino calculations and movement
                if self.dest:
                    # Calculate angle difference
                    # Note that angles will be measured from horizontal and in degrees

                    or_angle = 90 - or_angle # correct orientation angle for consistent angle measure

                    dir_dx = center[0] - self.dest[0]
                    dir_dy = center[1] - self.dest[1]

                    dir_angle = math.atan2(dir_dy, dir_dx) # atan2 is better than atan
                    dir_angle = 180 - dir_angle * 180/math.pi # correct direction angle

                    diff = dir_angle - or_angle
                    if diff > 180:
                        diff = 180 - diff

                    self.doAction(diff, center)

            cv2.imshow('Create Tracker', vis)

            # Quit on ESC
            ch = 0xFF & cv2.waitKey(5)
            if ch == 27:
                break

        self.robot.sendCommand('s')
        cv2.destroyAllWindows()
Esempio n. 24
0
class Main:
    def __init__(self):
        pygame.init()

        # Setting variables
        self.pathToProjects = ""

        # Getting launcher settings
        self.getLauncherSettings()

        # Launcher window
        self.window = pygame.display.set_mode(SIZE)
        pygame.display.set_caption("Launcher")

        # Launcher icon
        launcherIcon = loadImage("launcher/icon.png")
        pygame.display.set_icon(launcherIcon)

        # Current folder
        self.currentFolder = os.getcwd()

        # Boolean variables
        self.running = True

        # Clock
        self.clock = pygame.time.Clock()

        # Launcher
        self.launcher = Launcher()

        # Create
        self.create = Create(self.pathToProjects)

        # Path
        self.path = ""

        # Gameloop
        self.loop()

    # Getting launcher settings
    def getLauncherSettings(self):
        settings = codecs.open("launcher/settings.vn", "r", "utf-8")
        content = clearLines(settings.read().split("\n"))
        for line in content:
            line = line.replace(" ", "")
            setting, value = line.split("=")
            if setting == "PATHTOPROJECTS": self.pathToProjects = value

        self.pathToProjects = os.getcwd() + "/projects/"

    # Handling events
    def events(self):
        for event in pygame.event.get():
            if event.type == pygame.QUIT:
                self.end()

            # Handling buttons
            for button in self.launcher.buttons:
                if event.type == pygame.MOUSEMOTION:
                    if mouseCollision(button.xy, button.wh, event.pos):
                        button.hover = True
                    else:
                        button.hover = False
                if event.type == pygame.MOUSEBUTTONDOWN:
                    if mouseCollision(button.xy, button.wh, event.pos):
                        button.click = True
                        self.buttonActions(button)
                    else:
                        button.click = False

            # Handling links
            for link in self.launcher.links:
                if event.type == pygame.MOUSEMOTION:
                    if mouseCollision(link.xy, link.twh, event.pos):
                        link.hover = True
                    else:
                        link.hover = False
                if event.type == pygame.MOUSEBUTTONDOWN:
                    if mouseCollision(link.xy, link.twh, event.pos):
                        link.selected = True
                    else:
                        link.selected = False

    # Button actions
    def buttonActions(self, button):
        # Start selected project
        if button.name == "startproject":
            # Getting the name of the selected project
            projectname = ""
            for link in self.launcher.links:
                if link.selected == True: projectname = link.rtrn
            if projectname == "": return
            self.startProject(projectname)

        # Create new project
        elif button.name == "createproject":
            self.create.createProject("new")
            self.launcher.createProjectList()

        # Updating the list of projects
        elif button.name == "updatelistcprojects":
            self.launcher.createProjectList()

        # Deleting the selected project
        elif button.name == "deleteproject":
            projectname = ""
            for link in self.launcher.links:
                if link.selected == True: projectname = link.rtrn
            if projectname == "": return
            self.create.deleteProject(projectname)
            self.launcher.createProjectList()

    # Intermediant calculations
    def update(self):
        self.clock.tick(FPS)
        self.events()

    # Rendering game objects
    def render(self):
        self.window.fill(WHITE)

        # scImage(self.window, "launcher/background.jpg", (0,0), SIZE)

        self.launcher.drawObjects(self.window)

        pygame.display.update()

    # Gameloop
    def loop(self):
        while self.running:
            self.update()
            self.render()

    # Start project
    def startProject(self, projectName):
        self.path = self.pathToProjects + projectName
        self.end()

    # Turn off the launcher
    def end(self):
        self.running = False
    



# -----------------------------------      小艾       ------------------------------------------
xiaoai = XiaoAi()

# 将任务加入小艾的队列
for item in aim_page:
    xiaoai.add_task(item)

for item in aim_tax:
    xiaoai.add_task(item)

# 开始执行自动化生成
xiaoai.start()

# -----------------------------------      创建文件       ------------------------------------------

# 选择路径  设置为存储路径
# tk.select_folder('AIM_FOLDER')
# path = setting.AIM_FOLDER

total_list = page + tax
tk.select_folder('AIM_FOLDER')
# 创建文件
create = Create(folder=tk.aim_folder,file_list=total_list)
create.create_file()


Esempio n. 26
0
#!/usr/bin/env python
#http://docs.python.org/library/optparse.html

from sys import argv
import os
from create import Create
from destroy import Destroy
from optparse import OptionParser

parser = OptionParser()
parser.add_option('-c',
                  '--create',
                  dest='create_action',
                  help="create a new app")
parser.add_option('-d',
                  '--destroy',
                  dest='destroy_action',
                  help="destroy an existing app")
(options, args) = parser.parse_args(argv)

if options.create_action:
    app_name = options.create_action
    Create(app_name)
elif options.destroy_action:
    app_name = options.destroy_action
    Destroy(app_name)
else:
    parser.print_help()
Esempio n. 27
0
        r.waitDistance(fwd_distance)
        r.stop()
        sleep(.25)
    in_file.close()


def via(r, filename):
    """Drive the robot according to data on each line in file.

    Keyword arguments:
    r -- robot object and serial connection
    filename -- data file with waypoints

    Returns: nothing, moves to points in filename.

    """
    pass
    #sense distance
    #waitAngle
    #waitDistance
    #sleep(long)
    #shutdown


if __name__ == '__main__':
    r = Create(SERIAL_PORT)
    filename = input("Please enter name of data file: ")
    load_numbers(r, filename)
    sleep(50)
    r.shutdown()
Esempio n. 28
0
# PROJET PYTHON KAROLAK 2017
# BURBAUD Pierre - GNERUCCI Maxime
# Script pour inscrire un fichier csv dans une base de donnée.
# Programme principal
# /!\ Le CSV doit contenir des dates de naissance pour tous les utilisateurs. /!\
#!/usr/bin/env python
# -*- coding: utf-8 -*-

import os
from update import Update
from create import Create

# Vérifie si la base existe déjà, si elle existe : utilise la fonction update autrement la fonction create.
if os.path.isfile("./file_db.db"):
    Update()
else:
    Create()
Esempio n. 29
0
class View(QWidget):

    def __init__(self):
        super().__init__()
        self.__create = Create(self)
        self.btn_restart = QPushButton('Start', self)
        self.new_game = QPushButton('New game', self)
        self.set_chip = QPushButton('Set chip', self)
        self.btn_show_statistic = QPushButton('Show statistic', self)
        self.le = QLineEdit(self)
        self.text = QTextEdit(self)
        self.set_player1 = QComboBox(self)
        self.set_player2 = QComboBox(self)
        self.init_comboBox()

        self.init_base_ui()

    def init_comboBox(self):
        list_of_players = self.__create.get_list_of_players()
        for i in list_of_players:
            self.set_player1.addItem(i)
            self.set_player2.addItem(i)

    def init_base_ui(self):
        self.setGeometry(600, 600, 600, 600)
        self.text.setTextInteractionFlags(Qt.TextSelectableByMouse)

        self.btn_restart.setEnabled(False)
        self.set_player1.setEnabled(False)
        self.set_player2.setEnabled(False)
        self.set_chip.setEnabled(False)
        self.le.setEnabled(False)

        midL = QVBoxLayout()
        midL.addWidget(self.le)
        midL.addWidget(self.set_chip)
        midL.addWidget(self.text)
        midL.addWidget(self.btn_restart)
        midL.addWidget(self.new_game)

        leftL = QVBoxLayout()
        leftL.addWidget(self.set_player1)
        leftL.addStretch(1)

        rightL = QVBoxLayout()
        rightL.addWidget(self.set_player2)
        rightL.addStretch(1)
        rightL.addWidget(self.btn_show_statistic)

        mainVL = QHBoxLayout()
        mainVL.addLayout(leftL)
        mainVL.addLayout(midL)
        mainVL.addLayout(rightL)

        self.setLayout(mainVL)

        self.set_chip.clicked.connect(self.show_set_chip)
        self.new_game.clicked.connect(self.new_game_clicked)
        self.btn_restart.clicked.connect(self.restart_clicked)
        self.set_player1.activated[str].connect(self.on_activated_player1)
        self.set_player2.activated[str].connect(self.on_activated_player2)
        self.btn_show_statistic.clicked.connect(self.show_statistic)

        self.setWindowTitle('6v6')
        self.show()

    def new_game_clicked(self):
        self.btn_restart.setEnabled(False)
        self.set_player1.setEnabled(False)
        self.set_player2.setEnabled(False)
        self.btn_show_statistic.setEnabled(True)
        self.le.setEnabled(False)
        self.le.setText('')
        self.text.setText('')
        self.__create.def_param()
        self.set_chip.setEnabled(True)

    def restart_clicked(self):
        self.__create.new_game()
        self.__create.game.start_in_view()
        self.btn_restart.setEnabled(False)

    def show_statistic(self):
        text, ok = QInputDialog.getText(self, 'Input Dialog', 'Enter name:')
        temp = Statistic.get_player_stat(text)
        self.text.insertPlainText('\n' + text + ' -  games: ' + str(temp[0]) +
                                  ' win rate: ' + str(temp[1]) +
                                  ' chip rate: ' + str(temp[2]) + '\n')
        self.text.ensureCursorVisible()

    def show_set_chip(self):
        text, ok = QInputDialog.getInt(self, 'Input Dialog', 'Enter chip:')

        if ok:
            self.le.setText(str(text))

        self.set_chip.setEnabled(False)
        self.__create.set_chip(int(text))
        self.set_player1.setEnabled(True)
        self.btn_show_statistic.setEnabled(False)

    def on_activated_player1(self, text):
        self.text.insertPlainText('\n'+text+'\n')
        self.text.ensureCursorVisible()
        self.set_player1.setEnabled(False)
        list_of_players = self.__create.get_list_of_players()
        if text == list_of_players[0]:
            name, ok1 = QInputDialog.getText(self, 'Input Dialog', 'Enter name:')
            self.__create.set_player_ov(1, text, name)
        else:
            self.__create.set_player_ov(1, text, text)
        self.set_player2.setEnabled(True)

    def on_activated_player2(self, text):
        self.text.insertPlainText('\n'+text+'\n')
        self.text.ensureCursorVisible()
        self.set_player2.setEnabled(False)
        list_of_players = self.__create.get_list_of_players()
        if text == list_of_players[0]:
            name, ok1 = QInputDialog.getText(self, 'Input Dialog', 'Enter name:')
            self.__create.set_player_ov(2, text, name)
        else:
            self.__create.set_player_ov(2, text, text)
        self.btn_restart.setEnabled(True)

    def choose_for_man(self, pull):
        check = 0
        text = 0
        while check == 0:
            text, ok = QInputDialog.getInt(self, 'Input Dialog', 'Enter chip:')
            check = text in pull
            if check == 0:
                self.text.insertPlainText("\nyou don't have this chip, try again.")
                self.text.ensureCursorVisible()
        return text

    def print_score(self, name1, name2, score1, score2):
        self.text.insertPlainText("\n[" + name1 + " : " + name2 + "] " + str(score1) + " : " + str(score2))
        self.text.ensureCursorVisible()

    def print_pull(self, name, pull):
        self.text.insertPlainText("\n"+name + " chips: " + str(pull))
        self.text.ensureCursorVisible()

    def print_value(self, name, value):
        self.text.insertPlainText("\n"+name + " choose: " + str(value))
        self.text.ensureCursorVisible()

    def print_winner(self, winner):
        self.text.insertPlainText("\n"+winner)
        self.text.ensureCursorVisible()
        self.btn_show_statistic.setEnabled(True)