コード例 #1
0
def stream(unused_addr, *raws):
    raw_list = np.array([float(r) * 10.0 for r in raws]).astype(np.int64)
    config.is_calibration = cb.start_calibration(config.is_calibration,
                                                 raw_list)
    xyz = raw_list - config.calibration_numbers
    #print(len(raws), xyz[0], len(xyz), len(config.calibration_numbers), len(config.fitted_data))
    #print(fitted_data, raw_list)

    dist = []
    aves = np.array([0 for n in range(132)]).astype(np.int64)

    for label, f in enumerate(config.fitted_data):
        dist.append(np.linalg.norm(f - xyz))
        #print(label, f - xyz)
    '''
    for f in fitted_data:
        count = 0
        for label, a in enumerate(raws):
            aves += a
            count += 1
        aves = aves/count
        dist.append(np.linalg.norm(f - aves))
    '''

    predict_label = np.argmin(dist)
    print("predict_label", predict_label,
          config.face_expression[predict_label])
コード例 #2
0
ファイル: analyze.py プロジェクト: hungrykirby/maskQ
def serial_loop():
    with serial.Serial('COM5', 9600, timeout=0.1) as ser:
        between_a_and_a = False
        want_predict_num_array_raw = []
        arranged_sensor_date_list = []
        count_label = 0
        learner = None  #このスコープのみで有効な学習器
        if config.learner == "svm":
            learner = svm
        else:
            learner = na
        machine = learner.setup()
        try:
            while True:
                s = ser.readline()
                m = None
                try:
                    de = s.decode('utf-8')
                    m = re.match("\-*[\w]+", str(de))
                except Exception as e:
                    pass
                if (m != None):
                    num = m.group()
                    #print(want_predict_num_array)
                    if num == "a":
                        between_a_and_a = True
                        count_label = 0
                        want_predict_num_array_raw = []
                    elif between_a_and_a:
                        want_predict_num_array_raw.append(int(num))

                    if len(want_predict_num_array_raw) == config.sensor_nums:
                        count_label = 0
                        if config.calibration_numbers is not None:
                            want_predict_num_array = want_predict_num_array_raw - config.calibration_numbers
                        else:
                            want_predict_num_array = want_predict_num_array_raw
                        config.is_calibration = Calibrate.start_calibration(
                            config.is_calibration, want_predict_num_array)
                        while len(arranged_sensor_date_list) > 1:
                            arranged_sensor_date_list.pop(0)
                        arranged_sensor_date_list.append(
                            want_predict_num_array)
                        want_predict_num_array = []
                        between_a_and_a = False
                        ser.flushInput()
                        #print(xyz_array)
                        learner.stream(
                            machine,
                            np.array(arranged_sensor_date_list).astype(
                                np.int64))
                else:
                    pass
                    #print(type(m))
        except:
            print("Unexpected error:", sys.exc_info()[0])
            raise
        ser.close()
コード例 #3
0
ファイル: face.py プロジェクト: hungrykirby/maskQ
    def fetch_numbers(self, matched_group):
        is_calibration = config.is_calibration
        console_input_number = config.console_input_number

        self.calibration_numbers = config.calibration_numbers

        make_serial_flush = False

        if self.pre_console_input_number != console_input_number:
            self.pre_console_input_number = console_input_number
            self.count = 0
            self.count2 = 0  #????
            fn = os.path.join(os.getcwd(), self.mode, console_input_number)
            if not os.path.exists(fn):
                if console_input_number != "1025":
                    os.makedirs(fn)
            else:
                nums_past_all_fn = os.listdir(fn)
                nums_past_all = []
                for nums in nums_past_all_fn:
                    num, ext = os.path.splitext(os.path.splitext(nums)[0])
                    nums_past_all.append(int(num))
                if len(nums_past_all) != 0:
                    self.count = max(nums_past_all) + 1

        if matched_group == "a":  #strat byte == a
            self.between_a_and_a = True
            self.result_list_nums = []
        elif self.between_a_and_a:
            self.result_list_nums.append(int(matched_group))

        if len(self.result_list_nums) == self.sensor_nums:
            self.between_a_and_a = False
            make_serial_flush = True
            if is_calibration:
                is_calibration = Calibrate.start_calibration(
                    is_calibration,
                    np.array(self.result_list_nums).astype(np.int64))

            if self.count < self.pattern[
                    self.mode] and console_input_number.isdigit():
                if self.count2 < 5:
                    result_list = np.array(self.result_list_nums).astype(
                        np.int64) - self.calibration_numbers
                    if console_input_number != "1025":
                        self.write_ceps(result_list, console_input_number)
                    print("Calibration Mode is ", is_calibration,
                          ":input array = ", result_list, ":MODE = ",
                          self.mode)

        return is_calibration, make_serial_flush
コード例 #4
0
ファイル: TopLevel.py プロジェクト: gtmatu/PalomAlert
def main():
    global awayFromHome
    awayFromHome = False
    print("Top Level running")
    threads = []
    calibrated = False


    # Calibration Loop
    
    while calibrated == False:
        Readings = Calibrate.Calibrate()
        calibrated = Calibrate.Check(Readings)


    # Once calibrated, a thread is generated for each component

    threadComp = Thread(target=RunCompass.Run, args=(Readings["comp"],))
    threadAcc = Thread(target=RunAcc.Run)
    threadTemp = Thread(target=RunTemp.Run, args=(Readings["temp"],))

    threadComp.daemon = True    # Setting daemon flag to True forces the threads 
    threadAcc.daemon = True     # to terminate once the main program does
    threadTemp.daemon = True

    threads.append(threadComp)
    threads.append(threadAcc)
    threads.append(threadTemp)

    # Run the threads

    threadComp.start()
    threadAcc.start()
    threadTemp.start()

    # Keep the program running as to not terminate the daemonic threads
    while True:
        pass
コード例 #5
0
ファイル: SolverGUI.py プロジェクト: sheppardp/AutoCal
	def calibrate(self):
		
		np.set_printoptions(precision=2, suppress=True, linewidth=200)

		self.matchImages = []
		
		# for each image pair...
		for i in range(int(len(self.images)/2)):
			# Find it's circular points (and output details)
			self.matchImages.append(Calibrate.getCircularPoints(self.images[i*2][0], self.images[i*2+1][0]))
		
		self.setMatchImage(0)

		# Prepare a matrix for linear fitting of conic parameters
		DLT = []
		for matchImage in self.matchImages:
			DLT +=  matchImage[0]

		try:
			# Find the focal lengths
			if self.focalOnly.get() == 1:			
				# Linear fit of IAC parameters
				A = np.array(Calibrate.getFocalLengthConic(DLT))
				print("A: ", A)
				# Decompose the conic to a calibration matrix
				K = Calibrate.getFocalLength(A)
			# Same with full calibration matrix
			else:
				A = np.array(Calibrate.getConic(DLT))
				print("A: ", A)
				K = Calibrate.getCameraParameters(A)

			self.calibrationMatrixLabel.config(text=self.matrixDisplayString(K, "K"))

		except np.linalg.linalg.LinAlgError:
			self.calibrationMatrixLabel.config(text="DIAC not positive definite")
コード例 #6
0
def getRainValue(B0, B1):
    ########################## INPUT VALUES ########################################
    AttenSampleData = np.genfromtxt('AttenGenerator/Sample.txt', delimiter=';')
    AttenSampleYear = AttenSampleData[0]
    AttenSampleMonth = AttenSampleData[1]
    AttenSampleDay = AttenSampleData[2]
    AttenSampleHour = AttenSampleData[3]
    AttenSampleValue = AttenSampleData[4]
    ############################ HYPOTHESIS RESULT CALC ############################

    x = AttenSampleValue
    Xmean, Xmax, Xmin, Ymean, Ymax, Ymin = Calibrate.GetImpValues()
    Xnorm = (x - Xmean) / (Xmax - Xmin)
    Ynorm = B0 + B1 * (Xnorm)
    y = ((Ymax - Ymin) * (Ynorm)) + Ymean

    return y, x, AttenSampleYear, AttenSampleMonth, AttenSampleDay, AttenSampleHour
コード例 #7
0
    def do_GET(self):
        if(self.path.startswith(apiPrefix)):
            # All API request calls are handled and parsed within this function.
            # They are then passed onto the appropriate handler function.
            args = {}
            function = self.path.replace(apiPrefix, "").split(apiArgStringSep)[0]
            page = "self"
            if(apiClassFuncSep in function):
                page = function.split(apiClassFuncSep)[0]
                function = function.split(apiClassFuncSep)[1]
            if(apiArgStringSep in self.path):
                argString = self.path.split("?")[1]
                for kvp in argString.split("&"):
                    key = kvp.split("=")[0]
                    value = kvp.split("=")[1]
                    args[key] = value
                    print(key+":\t"+value)
            print("Page: \t"+page)
            print("Function:\t"+function)

            if(function == "saveLatestFrame"):
                result = cam.save_latest()
                if(result):
                    print("Updated latest frame!")
                    self.send_response(200)
                else:
                    self.send_response(500)

            elif(function == "getLatestFrame"):
                result = cam.capture()
                if(result != None):
                    print("Captured latest frame!")
                    self.send_response(200)
                    self.send_header("Content-type", "image/jpeg")
                    self.end_headers()
                    self.wfile.write(result)
                else:
                    self.send_response(500)
            elif(page == "Calibration"):
                if(function=="newBlank"):
                    newFile = Calibrate.newBlankFile()
                    print("Created new calibration file: "+newFile)
                    self.send_response(200)
                    self.send_header("Content-type", "text/text")
                    self.end_headers()
                    self.wfile.write(bytes(newFile))
                elif(function == "getAll"):
                    print("Fetching list of available config files...")
                    self.send_response(200)
                    self.send_header("Content-type", "text/text")
                    self.end_headers()
                    files = Calibrate.listCalibrationFiles()
                    for f in files:
                        self.wfile.write(bytes(f+","+files[f]+"\n"))
                elif(function == "LoadEl"):
                    print("Loading element from file...")
                    result = Calibrate.getElement(args["file"], args["el"])
                    self.send_response(200)
                    self.send_header("Content-type", "text/text")
                    self.end_headers()
                    self.wfile.write(bytes(result))
                elif(function == "delete"):
                    print("Deleting calibration file: "+args["file"])
                    Calibrate.deleteFile(args["file"])
                    self.send_response(200)
                    self.send_header("Content-type", "text/text")
                    self.end_headers()


        else:
            super(APIHandler, self).do_GET()
コード例 #8
0
def combined(inputfile, debug=False):
    start_file = inputfile
    img = cv2.imread(start_file)
    full_img = cv2.imread(start_file)

    original_img = deepcopy(img)

    fullheight, fullwidth, fullchannels = full_img.shape
    print "fullwidth %s" % fullwidth
    print "fullheight %s" % fullheight

    img, scale = ScaleImage.scale(full_img,1000)
    height, width, channels = img.shape
    scaled_img = deepcopy(img)

    ##First blur image in order to reduce noise
    blurred_img = deepcopy(img)

    print "Blurring image for filtering"
    blurred_img = cv2.GaussianBlur(blurred_img,(9,9),0)
    blurred_img = cv2.GaussianBlur(blurred_img,(9,9),0)
    blurred_img = cv2.GaussianBlur(blurred_img,(9,9),0)
    print "Blurring done"

    cv2.imwrite("Test_Images/Output_Images/blurred_img.jpg", blurred_img)


    ##Then find the average background color
    print "Calibrating color filtration"
    red,green,blue = Calibrate.findRed(blurred_img)

    ##Filter the image based on that average color
    print "Filtering blurred image"
    blurred_img = FilterImage.filter(blurred_img,red,green,blue)

    if (debug):
        showImage.showImage(blurred_img)

    ##Mask the original image based on the the blurred filter
    print "Masking original image based on blurred image"
    for y in range(0,height):
        for x in range(0,width):
            pxR = blurred_img[y,x,2]
            pxB = blurred_img[y,x,1]
            pxG = blurred_img[y,x,0]
            if ( (pxR == 0) and (pxG == 0) and (pxB == 0) ):
                img[y,x] = 0

    cv2.imwrite("Test_Images/Output_Images/justFiltered.jpg", img)

    if (debug):
        showImage.showImage(img, "Just filtered")

    morpher = ImageMorpher()

    openimg = deepcopy(img)

    ## Use morphology to get rid of erratic blobs and specs
    print "Doing morphology to fix blobbies"
    openimg = morpher.openWithSquare(openimg,7)

    openimg = morpher.closeWithSquare(openimg,7)

    openimg = cv2.cvtColor(openimg,cv2.COLOR_BGR2GRAY)

    for x in range(0,height):
        for y in range(0,width):
            px = openimg[x,y]
            if ( (px == 0) ):
                openimg[x,y] = 0
            else:
                openimg[x,y] = 255

    ##Get contours for remaining blobs
    print "Contouring blobbies"
    contoured_img, contours, hierarchy = cv2.findContours(openimg,cv2.RETR_TREE,cv2.CHAIN_APPROX_SIMPLE)

    ##Get rid of the tiny remaining specs
    print "Removing small blobs"
    for i in range(0, len(contours)):
        cnt = contours[i]
        if (cv2.contourArea(cnt) < 2000):
            cv2.drawContours(contoured_img,cnt,-1,0,thickness=cv2.FILLED)

    ##Create a new mask to remove contours
    print "Masking image based on removed contours"
    for x in range(0,height):
        for y in range(0,width):
            px = contoured_img[x,y]
            if ( (px == 0) ):
                img[x,y] = [0,0,0]
            else:
                continue

    if (debug):
        showImage.showImage(img, "Filtered and corrected")

    color_filtered_img = deepcopy(img)
    cv2.imwrite("Test_Images/Output_Images/1_Template_Color_Filtered.jpg",img)

    temp = deepcopy(color_filtered_img)


    ##Watershed works best with blurred image
    print "Blurring image for watershed algorithm"
    img = cv2.GaussianBlur(img,(9,9),0)
    img = cv2.GaussianBlur(img,(9,9),0)

    #####
    #Watershed segmentation
                           
    b,g,r = cv2.split(img)
    rgb_img = cv2.merge([r,g,b])

    gray = cv2.cvtColor(img,cv2.COLOR_BGR2GRAY)
    ret, thresh = cv2.threshold(gray,0,255,cv2.THRESH_BINARY_INV+cv2.THRESH_OTSU)

    # noise removal
    kernel = np.ones((2,2),np.uint8)
    closing = cv2.morphologyEx(thresh,cv2.MORPH_CLOSE,kernel, iterations = 2)

    # sure background area
    sure_bg = cv2.dilate(closing,kernel,iterations=1)

    # Finding sure foreground area
    dist_transform = cv2.distanceTransform(sure_bg,cv2.DIST_L2,3)

    # Threshold
    ret, sure_fg = cv2.threshold(dist_transform,0.1*dist_transform.max(),255,0)

    # Finding unknown region
    sure_fg = np.uint8(sure_fg)
    unknown = cv2.subtract(sure_bg,sure_fg)

    # Marker labelling
    ret, markers = cv2.connectedComponents(sure_fg)

    # Add one to all labels so that sure background is not 0, but 1
    markers = markers+1

    # Now, mark the region of unknown with zero
    markers[unknown==255] = 0

    markers = cv2.watershed(img,markers)
    img[markers == -1] = [255,0,0]

    cv2.imwrite('Test_Images/Output_Images/2_Template_Watershedded.jpg',img)

    if (debug):
        showImage.showImage(img,"Template_Watershedded")

    water_img = deepcopy(img)

    new_img = img

    for x in range(1,height-1):
        for y in range(1,width-1):
            if markers[x,y] == -1:
                new_img[x,y] = [255,255,255]
            else:
                new_img[x,y] = [0,0,0]

    cv2.imwrite('Test_Images/Output_Images/3_Template_Just_Watershed_Edges.jpg',new_img)


    #####
    #Hough Circles
    print "Doing Hough cirlces on watershedded edges"
    scimg = cv2.imread('Test_Images/Output_Images/3_Template_Just_Watershed_Edges.jpg',0)
    #scimg = cv2.medianBlur(scimg,5)
    sccimg = cv2.cvtColor(scimg,cv2.COLOR_GRAY2BGR)

    circles = cv2.HoughCircles(scimg,cv2.HOUGH_GRADIENT,1,100,
                                param1=50,param2=20,minRadius=30,maxRadius=100)
    ##circles = cv2.HoughCircles(scimg,cv2.HOUGH_GRADIENT,1,50,
    ##                            param1=50,param2=15,minRadius=15,maxRadius=50)

    counter = 0

    radsum = 0

    try:    
        print circles.shape
    except Exception, e:
        print e
コード例 #9
0
ファイル: GUI_support.py プロジェクト: mohalamino/MR360L
def calibrate():
        print ('Calibrate')
        w.Calibration.configure(state=DISABLED,cursor='arrow')
        Calibrate.create_Calibration_Mode (root,w)
コード例 #10
0
window.resizable(0, 0)
window.config(bg="white")

##################### IMPORT THE CALIBRATION AND ALERT #########################

import Calibrate
import RainValueCalc

############################# DEFINITIONS ######################################

TimerFlag = True
sTime = 5000
graphDataY = np.zeros(9)
graphDataX = np.ones(9) * (-47)
counterG = 0
B0, B1 = Calibrate.RunCalibrate()
PromR = np.ones(9)
PromVal = 0
xList = [" ", " ", " ", " ", " ", " ", " ", " ", " "]
clr = "#b5c3cb"
############################# FRAMES CONFIG ####################################

linkDetail = Frame()
linkDetail.pack()


def linkDetailTimer():
    linkDetail.config(bg=clr)
    linkDetail.config(width="1300", height="100")
    linkDetail.config(bd=5)
    linkDetail.config(relief="ridge")
コード例 #11
0
def InitializeStepEngine(order_list, image_list, options, parameters, timedata):	
	## 		Connect to the step engine and turn off the joystick
	ConnectSimple(1, "COM4", 9600, 0)
	SetJoystickOff() #   
	
	
	## 		We find any potential difference between the speed we set, and the speed we get
	SetVelocityToFactor(0.1,0.1,0,0) # This is noise
	vel_fac = GetVelocityFactor()
	x_vel_fac, y_vel_fac = vel_fac[0], vel_fac[1]
	speed_error = CalcSpeedError(0.3) 
	print "speed error is ", speed_error

	
	## 		We callibrate our positions, so that the inlets are where we wants them to be
	left_inlet, right_inlet = Calibrate(options.needs_calibrate)
	# We don't actually do anything with them atm :D
	
	## 	 	We find the appropriate starting position
	if options.starting_left:
		start_x = 0
	else:
		start_x = -35
	MoveToAbsolutePosition(start_x,0,0,0,1) ## We assume that we are at the left inlet
	
	
	## 	 	If we do not have a good average image, we fix that.
	if options.needs_average:
		dirt_arr = GetAverageImage(options)
	else:
		dirt_im = Image.open("Images/Averaging/average_image.jpg")
		dirt_arr = np.array(dirt_im) 
		dirt_arr= dirt_arr.astype(np.float32)
		
	## Remove old image files if we intend to save new ones
	if options.printing_output:
#		nothing = raw_input("Press enter to remove old image files")
		contour_folder =  "Images/Contours"
		positions_folder = "Images/Positions"
		clear_folder(contour_folder) # Makes sure we only store the images from this particular run. 
		clear_folder(positions_folder)
		remove_old_images()


	##	 	We let the user find a particle
	SetJoystickOn(True, True)
	print "Press the star tracking button to initiate tracking of the particle closes to the middle"
	
	state = DetectorState(parameters, options)
	state.speed_error = speed_error
	state.vel_fac = [x_vel_fac, y_vel_fac]

	
	while True:
		if not order_list.empty():
			if order_list.get() == "start_tracking":
				break
		im = ImageGrab.grab(parameters.box)
		contours, pix  	= GetContours(im, dirt_arr, 210, printing_output=False, iteration=0)
		best_contour_nr, positions = DetectParticle(state,contours,0, timedata,pix, parameters, options, initialize=True) # i is the current nr of runs
		if best_contour_nr < 0:
			continue
		cv2.drawContours(pix,[contours[best_contour_nr]],-1,(0,255,0),3)
		im = Image.fromarray(pix)
		image_list.put(im)
		sleep(1.5/parameters.fps_max)
	
	##	 	We find the velocity we were going at
	vel_approx = CalcVelocity(0.1)
	print "vel approx is ", vel_approx


	state.step_vel = np.array([vel_approx[0],vel_approx[1]])
	state.going_right = vel_approx[0]<0
	state.flowing_right = vel_approx[0]<0
	print " We think we are going right: ", state.going_right
	print " We think we are going right: ", state.flowing_right

	## 		We set the step engine to move at this speed
	SetJoystickOff()
	##### MAYBE WE SHOULD INCLUDE THE SPEED ERROR HERE? I THINK SO BUT LET'S TEST THAT IT'S REASONABLE FIRST
	SetSpeed(vel_approx[0]/x_vel_fac, vel_approx[1]/y_vel_fac, 0, 0, max_speed = 3.0/(min(x_vel_fac, y_vel_fac)))
	
	 
#	return np.array([vel_approx[0],vel_approx[1]]), dirt_arr, speed_error, [x_vel_fac, y_vel_fac], going_right
	return dirt_arr, state
コード例 #12
0
ファイル: GUI_support.py プロジェクト: mohalamino/MR360L
def calibrate():
        print ('Calibrate')
        Calibrate.create_Calibration_Mode (root)
コード例 #13
0
def process_calibration_parameters():
    '''
    --------------------------------------------------------------------
    This function defines parameters that are used for calibration of
    the chi_n_vec
    --------------------------------------------------------------------
    INPUTS:
    S           = integer in [3, 80], number of periods an individual
                  lives
    hours_worked_file_name
                = string, name of the hours worked STATA file
    hours_worked_file_years
                = string, years included in the names of the STATA files
                  with hours worked data
    file_extensions
                = string, STATA data file extension
    consumption_file_name
                = string, name of the STATA file that contains data on
                  average monthly consumption expenditure and income
    hours_worked_file_parameter_name
                = string, header of the dataset for hours worked in the
                  STATA file
    hours_worked_file_parameter_name2
                = string, header of the dataset for number of persons
                  in the STATA file
    time_endowment
                = integer, numer of total weekly hours that can be used
                  for work
    files_path  = string, path where the source STATA files are saved


    OBJECTS CREATED WITHIN FUNCTION:
    hours_worked_file_complete_name
                = string, complete name of the hours worked STATA file
                  that includes year and file extension
    consumption_file_complete_name
                = string, complete name of the consumption and income STATA
                  file that includes file extension
    hours_worked_file_parameter
                = string, header of the dataset for hours worked in the
                  STATA file
    hours_worked_file_parameter2
                = string, header of the dataset for number of individuals
                  in the STATA file
    consumption_file_parameter
                = string, header of the dataset for average monthly
                  consumption expenditure in the STATA file
    consumption_file_parameter2
                = string, head of the dataset for income in the STATA file
    consumption_file_year
                = year of the data for average income by age of an individual
    years       = string, elements of the years_list
    years_list  = list, years of hours worked data

    FILES CREATED BY THIS FUNCTION: None

    RETURNS: calibration_params
    --------------------------------------------------------------------
    '''

    with open("parameters.json") as json_data_file:
        data = json.load(json_data_file)

    calibration_data = data['calibration']
    print(calibration_data)

    S = calibration_data['S']
    hours_worked_file_name = calibration_data['hours_worked_file_name']
    hours_worked_file_years = calibration_data['hours_worked_file_years']
    file_extensions = calibration_data['file_extensions']
    consumption_file_name = calibration_data['consumption_file_name']
    hours_worked_file_parameter_name = calibration_data[
        'hours_worked_file_parameter']
    hours_worked_file_parameter_name2 = calibration_data[
        'hours_worked_file_parameter2']
    population_by_age_file_name = calibration_data[
        'population_by_age_file_name']
    population_by_age_file_parameter = calibration_data[
        'population_by_age_file_parameter']
    population_by_age_sheet_name = calibration_data[
        'population_by_age_sheet_name']

    time_endowment = calibration_data['time_endowment']

    files_path = calibration_data['files_path']

    years = hours_worked_file_years.split(" ")
    hours_worked_file_complete_name = []
    hours_worked_file_parameter = []
    hours_worked_file_parameter2 = []
    consumption_file_parameter = []
    consumption_file_parameter2 = []
    years_list = []

    for year in years:
        file_name = hours_worked_file_name + "_" + year + "." + file_extensions
        hours_worked_file_complete_name.append(file_name)
        parameter_name = hours_worked_file_parameter_name + "_" + year
        parameter_name2 = hours_worked_file_parameter_name2 + "_" + year
        hours_worked_file_parameter.append(parameter_name)
        hours_worked_file_parameter2.append(parameter_name2)
        years_list.append(year)

    consumption_file_parameter = calibration_data['consumption_file_parameter']
    consumption_file_parameter2 = calibration_data[
        'consumption_file_parameter2']
    consumption_file_year = calibration_data['consumption_file_year']

    print(years_list)

    print(hours_worked_file_complete_name)
    print(hours_worked_file_parameter)
    print(hours_worked_file_parameter2)

    consumption_file_complete_name = consumption_file_name + "." + file_extensions

    print(consumption_file_complete_name)

    calibration_params = Calibrate.Calibrate(
        S, hours_worked_file_complete_name, consumption_file_complete_name,
        hours_worked_file_parameter, hours_worked_file_parameter2,
        consumption_file_parameter, consumption_file_parameter2,
        consumption_file_year, population_by_age_file_name,
        population_by_age_file_parameter, population_by_age_sheet_name,
        files_path, years_list, time_endowment)

    print(calibration_params)

    return calibration_params
コード例 #14
0
import os
import sys
import threading
sys.path.append('../')
from Prologix import Prologix

from Configuration import *
import CollectDAC
import Calibrate
import CollectBias
import CollectCurrent
import CollectScan
import CollectScan_Drift2
import CollectBiasScan
if data == 'calibrate':
    Calibrate.calibrate()
elif data == 'bias':
    CollectBias.bias()

elif data == 'dac':
    CollectDAC.dac()

elif data == 'current':
    print('Collecting current.')
    CollectCurrent.current()
elif data == 'scan':
    CollectScan.scan()
elif data == 'bias_scan':
    CollectBiasScan.scan()
elif data == 'scan_drift2':
    CollectScan_Drift2.scan()
コード例 #15
0
def serial_loop():
    with serial.Serial('COM5', 9600, timeout=0.1) as ser:
        setPortCount = 0

        between_a_and_a = False
        want_predict_num_array_raw = []
        arranged_sensor_date_list = []
        count_label = 0
        machine = svm.setup()
        try:
            while True:
                s = ser.readline()
                m = None

                if setPortCount < 100:
                    print("waiting port now" + str(setPortCount))
                    ser.write(bytes(str(2), 'UTF-8'))

                try:
                    de = s.decode('utf-8')
                    m = re.match("\-*[\w]+", str(de))
                except Exception as e:
                    pass
                if not m is None:
                    num = m.group()
                    setPortCount = setPortCount + 1
                    if num == "a":

                        between_a_and_a = True
                        count_label = 0
                        want_predict_num_array_raw = []
                    elif between_a_and_a:
                        if int(num) == 0:
                            print("重篤なエラーがあります")
                        want_predict_num_array_raw.append(int(num))

                    if len(want_predict_num_array_raw) == config.sensor_nums:
                        count_label = 0
                        if config.calibration_numbers is not None:
                            want_predict_num_array = want_predict_num_array_raw - config.calibration_numbers
                        else:
                            want_predict_num_array = want_predict_num_array_raw
                        config.is_calibration = Calibrate.start_calibration(
                            config.is_calibration, want_predict_num_array)
                        while len(arranged_sensor_date_list) > 1:
                            arranged_sensor_date_list.pop(0)
                        arranged_sensor_date_list.append(
                            want_predict_num_array)
                        want_predict_num_array = []
                        between_a_and_a = False
                        ser.flushInput()
                        svm.stream_w_face(
                            machine,
                            np.array(arranged_sensor_date_list).astype(
                                np.int64))
                else:
                    pass
        except:
            print("Unexpected error:", sys.exc_info()[0])
            raise
        ser.close()
コード例 #16
0
ファイル: osc_analyze.py プロジェクト: hungrykirby/maskQ
def serial_loop():
    '''
    OSC
    '''
    parser = argparse.ArgumentParser()
    parser.add_argument("--ip",
                        default="127.0.0.1",
                        help="The ip of the OSC server")
    parser.add_argument("--port",
                        type=int,
                        default=12345,
                        help="The port the OSC server is listening on")
    args = parser.parse_args()

    client = udp_client.UDPClient(args.ip, args.port)
    '''
    Serial
    '''
    with serial.Serial('COM5', 9600, timeout=0.1) as ser:

        setPortCount = 0

        between_a_and_a = False
        want_predict_num_array_raw = []
        arranged_sensor_date_list = []
        count_label = 0
        learner = None  #このスコープのみで有効な学習器
        if config.learner == "svm":
            learner = svm
        else:
            learner = na
        machine = learner.setup()
        try:
            while True:
                s = ser.readline()
                m = None

                if setPortCount < 100:
                    print("waiting port now" + str(setPortCount))
                    ser.write(bytes(str(2), 'UTF-8'))

                try:
                    de = s.decode('utf-8')
                    m = re.match("\-*[\w]+", str(de))
                except Exception as e:
                    pass
                if (m != None):

                    setPortCount = setPortCount + 1

                    num = m.group()
                    #print(want_predict_num_array)
                    if num == "a":
                        between_a_and_a = True
                        count_label = 0
                        want_predict_num_array_raw = []
                    elif between_a_and_a:
                        want_predict_num_array_raw.append(int(num))

                    if len(want_predict_num_array_raw) == config.sensor_nums:
                        count_label = 0
                        if config.calibration_numbers is not None:
                            want_predict_num_array = want_predict_num_array_raw - config.calibration_numbers
                        else:
                            want_predict_num_array = want_predict_num_array_raw
                        config.is_calibration = Calibrate.start_calibration(
                            config.is_calibration, want_predict_num_array)
                        while len(arranged_sensor_date_list) > 1:
                            arranged_sensor_date_list.pop(0)
                        arranged_sensor_date_list.append(
                            want_predict_num_array)
                        want_predict_num_array = []
                        between_a_and_a = False
                        ser.flushInput()
                        #print(arranged_sensor_date_list[0])
                        p_label = learner.stream(
                            machine,
                            np.array(arranged_sensor_date_list).astype(
                                np.int64))

                        #print(type(p_label))
                        msg = osc_message_builder.OscMessageBuilder(
                            address="/emotion")
                        msg.add_arg(int(p_label))
                        #msg = osc_message_builder.OscMessageBuilder(address = "/raw")
                        for a in arranged_sensor_date_list[0]:
                            msg.add_arg(int(a))
                        msg = msg.build()
                        client.send(msg)
                else:
                    pass
                    #print(type(m))
        except:
            print("Unexpected error:", sys.exc_info()[0])
            raise
        ser.close()
コード例 #17
0
                    job_states[jobs[i]] = state

                print "Current states: " + str(result_map)
                time.sleep(5)
                if finish_counter == NUMBER_JOBS_PER_STAGE:
                    break
            runtime.append(time.time() - starttime[stage])
            print "#################################################"
            print "Runtime for Stage " + str(stage) + " is: " + str(
                runtime[stage]) + " s; Runtime per Job: " + str(
                    runtime[stage] / NUMBER_JOBS_PER_STAGE)
            print "finished with Stage number: " + str(stage)
            print "#################################################"
            print "Performing checking"
            print "Running Calibrate.py"
            if (Calibrate.Calibrate() == 1):
                print "Calibration successful"
            else:
                print "Calibration failed, proceed with caution"

            print "#################################################"
            print "Checking the actual output files"
            RERUN_LIST = FileTest.FileTest(WORK_DIR, SIMULATION_DIR_PREFIX,
                                           OUTPUT_FILE_EXTENSION,
                                           NUMBER_JOBS_PER_STAGE)
            if len(RERUN_LIST) != 0:
                print "THE FOLLOWING JOBS FAILED: " + str(out)
                print "Attempting to re-submit"
                rerun_jobs = []
                rerun_job_start_times = {}
                rerun_job_states = {}