def saveData(self, featureName, inputParamValList, dataDictionary): from Utils.DataUtils import DataUtils """inputParamList=[] inputParamValList=[] for tupleVal in inputParamTuple: inputParamList.append(tupleVal[0]) inputParamValList.append(tupleVal[1]) """ inputKeyList = [] inputKeyList.append(featureName) """for inputParam in inputParamList: inputKeyList.append(inputParam)""" featureKey = DataUtils.getUniqueKey(inputKeyList) inputParamListKey = DataUtils.getUniqueKey(inputParamValList) thisFeatureDict = {} #Check if this feature has been cached before if self.allFeaturesData.has_key(featureKey) is True: thisFeatureDict = self.allFeaturesData[featureKey] #Check if this input params set has been cached before if thisFeatureDict.has_key(inputParamListKey) is False: #Putting new entry thisFeatureDict[inputParamListKey] = dataDictionary else: #Replacing current entry thisFeatureDict[inputParamListKey] = dataDictionary self.allFeaturesData[featureKey] = thisFeatureDict else: thisFeatureDict = {} thisFeatureDict[inputParamListKey] = dataDictionary self.allFeaturesData[featureKey] = thisFeatureDict
class TrainUtils: def __init__(self) -> None: super().__init__() self.dataUtils = DataUtils() def prepareData(self, delay=5): ecgAll, fecg = self.dataUtils.readData(0) ecgAll = ecgAll[range(1), :] delayNum = ecgAll.shape[0] fecgAll = self.dataUtils.createDelayRepetition(fecg, delayNum, delay) for i in range(1, 2): ecg, fecg = self.dataUtils.readData(i) ecg = ecg[range(1), :] fecgDelayed = self.dataUtils.createDelayRepetition( fecg, delayNum, delay) ecgAll = np.append(ecgAll, ecg, axis=1) fecgAll = np.append(fecgAll, fecgDelayed, axis=1) ecgWindows, fecgWindows = self.dataUtils.windowingSig(ecgAll, fecgAll, windowSize=200) # fecgWindows = self.dataUtils.adaptFilterOnSig(ecgWindows, fecgWindows) # ecgWindows = self.dataUtils.calculateICA(ecgWindows, component=2) return ecgWindows, fecgWindows def trainTestSplit(self, sig, label, trainPercent, shuffle=True): X_train, X_test, y_train, y_test = train_test_split( sig, label, train_size=trainPercent, shuffle=shuffle) X_train = np.array(X_train) X_test = np.array(X_test) y_train = np.array(y_train) y_test = np.array(y_test) return X_train, X_test, y_train, y_test
def __init__(self, *args, **kwargs): super(RegisterFeatureTests, self).__init__(*args, **kwargs) self.__data = DataGenerateUtils() self.__register = RegisterPage() self.__create_bot = CreateBotPage() self.__data_set = DataUtils() self.valid_name = self.__data.create_name() self.valid_email = self.__data.create_email() self.valid_password = self.__data.create_password()
class test_DatasetUtils(unittest.TestCase): def setUp(self) -> None: super().setUp() self.datasetUtils = DataUtils() def test_generateCFAImages(self): rgbImages = self.datasetUtils.loadKodakDataset() cfaImages, image_size = self.datasetUtils.convertDatasetToCFA( rgbImages) self.assertIsNotNone(cfaImages) def test_saveNikonImage(self): self.datasetUtils.saveImageNikon()
def __init__(self, *args, **kwargs): super(CreateBotFeatureTests, self).__init__(*args, **kwargs) self.__data = DataGenerateUtils() self.__login = LoginPage() self.__create_bot = CreateBotPage() self.__register = RegisterPage() self.__appearance = AppearancePage() self.__create_bot_validation = CreateBotValidation() self.__drop_down_list = DropDownList() self.__data_set = DataUtils() self.valid_email = self.__data.create_email() self.valid_username = self.__data.create_name() self.valid_password = self.__data.create_password() self.faq_url = YAML_CONFIG.get("stub_faq_url")
class TestDataUtils(TestCase): def __init__(self, methodName: str = ...) -> None: super().__init__(methodName) self.dataUtils = DataUtils() def test_read_data(self): ecg, fecg = self.dataUtils.readData(0) self.assertIsNotNone(ecg) def test_addRepetitionDelay(self): ecg, fecg = self.dataUtils.readData(0) detectors = Detectors(200) # fecgDelayed = self.dataUtils.createDelayRepetition(fecg, 4, 5) # self.assertIsNotNone(fecgDelayed) r_peaks = detectors.hamilton_detector(ecg) pass
class LoginFeatureTests(BaseTest): def __init__(self, *args, **kwargs): super(LoginFeatureTests, self).__init__(*args, **kwargs) self.__data = DataGenerateUtils() self.__login = LoginPage() self.__create_bot = CreateBotPage() self.__register = RegisterPage() self.__data_set = DataUtils() self.valid_email = self.__data.create_email() self.valid_username = self.__data.create_name() self.valid_password = self.__data.create_password() def test_login_unsuccessfully_due_to_blank_fields(self): accounts = self.__data_set.get_data(INVALID_LOGIN_DATA) expected_errors = [account[2] for account in accounts[1:]] actual_errors = [] for account in accounts[1:]: email = account[0] password = account[1] self.__login.open_login_page() self.__login.login_with_account(email, password) actual_errors.append(self.__login.lbl_error_message.get_element_text()) self.assertEqual(expected_errors, actual_errors, "Assert Error : {0} != {1}".format(expected_errors, actual_errors)) self.assertTrue(self.__login.txt_header_text.lower() in self.__login.driver.page_source.lower(), "'{0}' text does not present in DOM".format(self.__login.txt_header_text)) self.assertTrue(self.__login.path_page in self.__login.driver.current_url, "{0} is not included in url".format(self.__login.path_page))
def __init__(self, *args, **kwargs): super(ChangePasswordTests, self).__init__(*args, **kwargs) self.__data = DataGenerateUtils() self.__login = LoginPage() self.__create_bot = CreateBotPage() self.__register = RegisterPage() self.__dashboard = DashboardPage() self.__appearance = AppearancePage() self.__create_bot_validation = CreateBotValidation() self.__drop_down_list = DropDownList() self.__change_password = ChangePasswordPage() self.__data_set = DataUtils() self.valid_email = self.__data.create_email() self.valid_username = self.__data.create_name() self.valid_password = self.__data.create_password() self.bot_name = "Test" self.invalid_faq = "google.com"
def getData(self, featureName, inputParamValList): from Utils.DataUtils import DataUtils """inputParamList=[] inputParamValList=[] print inputParamTuple for tupleVal in inputParamTuple: inputParamList.append(tupleVal[0]) inputParamValList.append(tupleVal[1]) """ inputKeyList = [] inputKeyList.append(featureName) """for inputParam in inputParamList: inputKeyList.append(inputParam) """ featureKey = DataUtils.getUniqueKey(inputKeyList) dataKey = DataUtils.getUniqueKey(inputParamValList) if self.allFeaturesData.has_key(featureKey) is True: featureDataList = self.allFeaturesData[featureKey] if featureDataList.has_key(dataKey) is True: return featureDataList[dataKey] return None
class RegisterFeatureTests(BaseTest): def __init__(self, *args, **kwargs): super(RegisterFeatureTests, self).__init__(*args, **kwargs) self.__data = DataGenerateUtils() self.__register = RegisterPage() self.__create_bot = CreateBotPage() self.__data_set = DataUtils() self.valid_name = self.__data.create_name() self.valid_email = self.__data.create_email() self.valid_password = self.__data.create_password() def test_register_new_account_successful(self): self.__register.open_register_page() self.__register.login_with_new_account(self.valid_name, self.valid_email, self.valid_password) self.__create_bot.wait_for_create_page() self.assertTrue( self.__create_bot.txt_header_text.lower() in self.__create_bot.get_header_text().lower(), "Expect header '{0}' but '{1}' found".format( self.__create_bot.txt_header_text, self.__create_bot.get_header_text())) self.assertTrue( self.__create_bot.path_page in self.__register.driver.current_url, "Current page url {0}".format(self.__register.driver.current_url)) def test_register_new_account_unsuccessful_with_invalid_inputs(self): accounts = self.__data_set.get_data(INVALID_REGISTER_DATA) expected_errors = [account[3] for account in accounts[1:]] errors = [] for account in accounts[1:]: fullname = account[0] email = account[1] password = account[2] self.__register.open_register_page() self.__register.login_with_new_account(fullname, email, password) errors.append(self.__register.lbl_error_message.get_element_text()) self.assertEqual( expected_errors, errors, "Assert Error : {0} != {1}".format(expected_errors, errors)) self.assertTrue( self.__register.txt_header_text.lower() in self.__register.driver.page_source.lower(), "'{0}' does not present in DOM".format( self.__register.txt_header_text)) self.assertTrue( self.__register.path_page in self.__register.driver.current_url, "{0} is not included in url".format(self.__register.path_page))
def __init__(self, *args, **kwargs): super(KnowledgeFeatureTests, self).__init__(*args, **kwargs) self.__data = DataGenerateUtils() self.__login = LoginPage() self.__create_bot = CreateBotPage() self.__register = RegisterPage() self.__appearance = AppearancePage() self.__knowledge_validation = KnowledgeValidation() self.__dashboard = DashboardPage() self.__knowledge = KnowledgePage() self.__data_set = DataUtils() self.valid_email = self.__data.create_email() self.valid_username = self.__data.create_name() self.valid_password = self.__data.create_password() self.faq_url = YAML_CONFIG.get("stub_manual_faq_url") self.invalid_faq = YAML_CONFIG.get("stub_invalid_faq_url")
def __init__(self, *args, **kwargs): super(AppearanceTests, self).__init__(*args, **kwargs) self.__data = DataGenerateUtils() self.__login = LoginPage() self.__create_bot = CreateBotPage() self.__register = RegisterPage() self.__appearance = AppearancePage() self.__create_bot_validation = CreateBotValidation() self.__drop_down_list = DropDownList() self.__chat_box_simulator = ClientSimulator() self.__loader = LoaderComponent() self.__data_set = DataUtils() self.valid_email = self.__data.create_email() self.valid_username = self.__data.create_name() self.valid_password = self.__data.create_password() self.bot_name = self.__data.create_uuid_number() self.faq_url = YAML_CONFIG.get("stub_faq_url")
def __init__(self, *args, **kwargs): super(TestAdminPages, self).__init__(*args, **kwargs) self.__data = DataGenerateUtils() self.__login = LoginPage() self.__create_bot = CreateBotPage() self.__register = RegisterPage() self.__dashboard = DashboardPage() self.__appearance = AppearancePage() self.__create_bot_validation = CreateBotValidation() self.__drop_down_list = DropDownList() self.__change_password = ChangePasswordPage() self.__knowledge = KnowledgePage() self.__data_set = DataUtils() self.__faq_knowledge_data_table_component = FaqKnowledgeDataTableComponent( ) self.valid_email = self.__data.create_email() self.valid_username = self.__data.create_name() self.valid_password = self.__data.create_password() self.bot_name = "Test" self.invalid_faq = "google.com" self.eyes = Eyes() self.eyes.api_key = YAML_CONFIG.get("eyes_api_key") self.eyes.force_full_page_screenshot = True self.eyes.stitch_mode = StitchMode.CSS
def __init__(self) -> None: super().__init__() self.dataUtils = DataUtils()
def setUp(self) -> None: super().setUp() self.datasetUtils = DataUtils()
def fetchInputAgents(self): if self.agentsFetchQuery is not None: from Utils.dbAdapter import dbAdapter from Utils.DataUtils import DataUtils from Utils.Log import Log dbAdapter = dbAdapter('REPLICASQL') self.agentsDataList = dbAdapter.fetchData(self.agentsFetchQuery) self.allAgentsDataDict = {} for agentData in self.agentsDataList: currentAgentData = {} #Converting complete agent data to dictionary for easy computation for element in agentData: currentAgentData[element[0]] = element[1] if currentAgentData['Grade'] not in (3, 4, 5): continue #Segregating parts of a key and generating key to calculate aggregate values for a key listOfKeyParts = [ currentAgentData['UserID'], currentAgentData['EmployeeId'], currentAgentData['Grade'], currentAgentData['GroupId'], currentAgentData['UserGroupName'], currentAgentData['limit'], currentAgentData['BucketSize'], currentAgentData['PPLLimit'] ] agentDataKey = DataUtils.getUniqueKey(listOfKeyParts) #To check if this agent key is already there in processed agents dictionary #Log.d(InputDataExtracter.TAG,str(agentDataKey)) if self.allAgentsDataDict.has_key(agentDataKey) is True: #If there was data corresponding to this agent key in all Agents dictionary previousAgentsData = self.allAgentsDataDict[agentDataKey] previousAgentsData[ 'LeadsCount'] = previousAgentsData['LeadsCount'] + 1 previousAgentsData['LeadsPPL'] = previousAgentsData[ 'LeadsPPL'] + currentAgentData['LeadsPPL'] previousAgentsData['L1Count'] = previousAgentsData[ 'L1Count'] + currentAgentData['L1Count'] previousAgentsData['L2Count'] = previousAgentsData[ 'L2Count'] + currentAgentData['L2Count'] previousAgentsData['L3Count'] = previousAgentsData[ 'L3Count'] + currentAgentData['L3Count'] else: #If there was no data previously for this agent in dictionary;previousAgentsData name misleading previousAgentsData = {} previousAgentsData['LeadsCount'] = 1 previousAgentsData['LeadsPPL'] = currentAgentData[ 'LeadsPPL'] previousAgentsData['Grade'] = currentAgentData['Grade'] previousAgentsData['GroupId'] = currentAgentData['GroupId'] previousAgentsData['GroupName'] = currentAgentData[ 'UserGroupName'] previousAgentsData['DailyLimit'] = currentAgentData[ 'limit'] previousAgentsData['BucketSize'] = currentAgentData[ 'BucketSize'] previousAgentsData['MaxLeadsPPLCount'] = currentAgentData[ 'PPLLimit'] previousAgentsData['L1Count'] = currentAgentData['L1Count'] previousAgentsData['L2Count'] = currentAgentData['L2Count'] previousAgentsData['L3Count'] = currentAgentData['L3Count'] previousAgentsData['UserId'] = currentAgentData['UserID'] previousAgentsData['EmployeeId'] = currentAgentData[ 'EmployeeId'] self.allAgentsDataDict[agentDataKey] = previousAgentsData return self.allAgentsDataDict else: return None
def __init__(self, methodName: str = ...) -> None: super().__init__(methodName) self.dataUtils = DataUtils()
def __init__(self, *args, **kwargs): super(BaseTest, self).__init__(*args, **kwargs) self.is_api_test = True data_path = path.join(FAQ_DATA_PATH, FAQ_URLS) self.data = DataUtils().get_data(file_name=data_path)
def __init__(self, methodName: str = ...) -> None: super().__init__(methodName) self.datasetUtils = DataUtils() self.evaluation = Evaluation()
class TestORCTOptimization(unittest.TestCase): def __init__(self, methodName: str = ...) -> None: super().__init__(methodName) self.datasetUtils = DataUtils() self.evaluation = Evaluation() def opt_func(self, X, twoComplement): n_particles = X.shape[0] # number of particles costs = [] for x in X: x = np.reshape(x, [2, 2]) filtered = compute_orct2(compute_orct1(twoComplement, x), x) filtered = (filtered + 255) / 2 def inverseFunction(data): data = data.astype('float32') * 2 - 255 data = compute_orct2inverse(data, x) data = compute_orct1inverse(data, x) return data sampleFunctionReverse = inverseFunction psnr, ssim, jpeg2000CompressionRatioAfter, jpeg2000CompressionRatioBefore = self.evaluation.evaluate( filtered, twoComplement, sampleFunctionReverse) cost = np.abs( (1 / psnr) * (1 / ssim) * 1 / (jpeg2000CompressionRatioAfter)) costs.append(cost) return np.array(costs) def test_orct12_optimization(self): bayer = self.datasetUtils.readCFAImages() twoComplement = self.datasetUtils.twoComplementMatrix(bayer) twoComplement = twoComplement.astype("float32") options = {'c1': 0.5, 'c2': 0.1, 'w': 0.9} optimizer = GlobalBestPSO(n_particles=10, dimensions=4, options=options) costFunction = partial(self.opt_func, twoComplement=twoComplement) cost, pos = optimizer.optimize(costFunction, iters=30) pass def test_orct12_(self): pos = np.asarray([0.39182592, 0.23747258, 0.51497874, -0.08751142]) x = np.reshape(pos, [2, 2]) # x = np.asarray([[0.05011018, -0.53709484], # [-1.1104253, -0.30699651]]) bayer = self.datasetUtils.readCFAImages() twoComplement = self.datasetUtils.twoComplementMatrix(bayer) twoComplement = twoComplement.astype("float32") filtered = compute_orct2(compute_orct1(twoComplement, x), x) filtered = (filtered + 255) / 2 def inverseFunction(data): data = data.astype('float32') * 2 - 255 data = compute_orct2inverse(data, x) data = compute_orct1inverse(data, x) return data sampleFunctionReverse = inverseFunction self.evaluation.evaluate(filtered, twoComplement, sampleFunctionReverse) pass def test_ocrtOptimizedWithDataset(self): pos = np.asarray([0.39182592, 0.23747258, 0.51497874, -0.08751142]) x = np.reshape(pos, [2, 2]) rgbImages = self.datasetUtils.loadKodakDataset() cfaImages, image_size = self.datasetUtils.convertDatasetToCFA( rgbImages) bayer = cfaImages[2, :, :] twoComplement = self.datasetUtils.twoComplementMatrix(bayer) twoComplement = twoComplement.astype("float32") filtered = compute_orct2plus3(compute_orct1(twoComplement, x), x) filtered = (filtered + 255) / 2 def inverseFunction(data): data = data.astype('float32') * 2 - 255 data = compute_orct2plus3inverse(data, x) data = compute_orct1inverse(data, x) return data sampleFunctionReverse = inverseFunction self.evaluation.evaluate(filtered, bayer, sampleFunctionReverse) pass def test_multiObjOptimization(self): algorithm = NSGA2(pop_size=10, n_offsprings=10, sampling=get_sampling("real_random"), crossover=get_crossover("real_sbx", prob=0.9, eta=15), mutation=get_mutation("real_pm", eta=20), eliminate_duplicates=True) termination = get_termination("n_gen", 5) bayer = self.datasetUtils.readCFAImages() twoComplement = self.datasetUtils.twoComplementMatrix(bayer) twoComplement = twoComplement.astype("float32") problem = MyProblem(twoComplement) res = minimize(problem, algorithm, termination, save_history=True, verbose=True) # Objective Space res.F = 1 / res.F plot = Scatter(title="Objective Space") plot.add(res.F) plot.show() print("Best filter{}".format(np.reshape(res.opt[-1].X, [2, 2])))
class ChangePasswordTests(BaseTest): def __init__(self, *args, **kwargs): super(ChangePasswordTests, self).__init__(*args, **kwargs) self.__data = DataGenerateUtils() self.__login = LoginPage() self.__create_bot = CreateBotPage() self.__register = RegisterPage() self.__dashboard = DashboardPage() self.__appearance = AppearancePage() self.__create_bot_validation = CreateBotValidation() self.__drop_down_list = DropDownList() self.__change_password = ChangePasswordPage() self.__data_set = DataUtils() self.valid_email = self.__data.create_email() self.valid_username = self.__data.create_name() self.valid_password = self.__data.create_password() self.bot_name = "Test" self.invalid_faq = "google.com" def setUp(self): super().setUp() try: self.sign_in_for_ui_test(self.valid_username, self.valid_email, self.valid_password, self.bot_name, self.invalid_faq, False) finally: self.__change_password.open_change_password_page() def test_change_password_unsuccessfully_with_invalid_data(self): invalid_data = self.__data_set.get_data( INVALID_DATA_FOR_CHANGE_PASSWORD) for data in invalid_data: old_password = data[0] new_password = data[1] confirm_password = data[2] error_message = data[3] self.__change_password.change_password(old_password, new_password, confirm_password) print(data) assert self.__change_password.get_error_message() == error_message, \ f"Expect error message '{error_message}' but '{self.__change_password.get_error_message()}' is returned" assert self.__change_password.btn_submit.get_element_text() == "RETRY", \ f"Expect button submit change to 'RETRY' but '{self.__change_password.btn_submit.get_element_text()}'" # Incorrect current password self.__change_password.change_password(self.valid_password + "123", "password", "password") assert self.__change_password.get_error_message() == "Your current password is not correct.", \ f"Expect error message 'Your current password is not correct.' " \ f"but '{self.__change_password.get_error_message()}' is returned" assert self.__change_password.btn_submit.get_element_text() == "RETRY", \ f"Expect button submit change to 'RETRY' but '{self.__change_password.btn_submit.get_element_text()}'" def test_change_password_unsuccessfully_with_wrong_current_password(self): # Make old password become incorrect old_password = self.valid_password + "123" new_password = "******" expected_error_message = "Your current password is not correct." self.__change_password.change_password(old_password, new_password, new_password) actual_error_message = self.__change_password.get_error_message() assert actual_error_message == expected_error_message, \ f"Expect '{expected_error_message}' but '{actual_error_message}' is displayed" assert self.__change_password.btn_submit.get_element_text() == "RETRY", \ f"Expect button submit change to 'RETRY' but '{self.__change_password.btn_submit.get_element_text()}'" def test_change_password_successfully(self): new_password = "******" success_message = "Your password has been updated successfully." # Change Password self.__change_password.change_password(self.valid_password, new_password, new_password) # Verify actual_message = self.__change_password.get_success_message() assert actual_message == success_message, \ f"Expect '{success_message}' but '{actual_message}' is displayed" self.__change_password.wait_for_button_back_to_dashboard_display() # Sign out self.__change_password.log_out() self.__login.wait_for_log_in_page() # Verify login successfully with new password self.__login.login_with_account(self.valid_email, new_password) self.__dashboard.wait_for_dashboard_page()
class TestORCT(unittest.TestCase): def __init__(self, methodName: str = ...) -> None: super().__init__(methodName) self.datasetUtils = DataUtils() self.evaluation = Evaluation() self.precisionFloatingPoint = 0 def test_orct1(self): bayer = cv2.imread("../Data/image.bmp") bayer = np.sum(bayer, axis=2).astype('float64') orct1Filtered = compute_orct1(bayer, precisionFloatingPoint=self.precisionFloatingPoint) pass def test_orct2(self): bayer = cv2.imread("../Data/image.bmp") bayer = np.sum(bayer, axis=2).astype('float64') orct2Filtered = compute_orct2(bayer, precisionFloatingPoint=self.precisionFloatingPoint) pass def test_orct23PlusReversible(self): bayer = cv2.imread("../Data/image.bmp") bayer = np.sum(bayer, axis=2).astype('float64') orct23Filtered = compute_orct2plus3(bayer, precisionFloatingPoint=self.precisionFloatingPoint) orct23FilteredInversed = compute_orct2plus3inverse(orct23Filtered, precisionFloatingPoint=self.precisionFloatingPoint) print("PSNR: {}".format(self.evaluation.calculate_psnr(bayer, np.round(orct23FilteredInversed)))) def test_orct1Reversible(self): bayer = cv2.imread("../Data/image.bmp") bayer = np.sum(bayer, axis=2).astype('float64') orct1Filtered = compute_orct1V2(bayer, precisionFloatingPoint=self.precisionFloatingPoint) orct1FilteredInversed = compute_orct1inverseV2(orct1Filtered, precisionFloatingPoint=self.precisionFloatingPoint) print("PSNR: {}".format(self.evaluation.calculate_psnr(bayer, np.round(orct1FilteredInversed)))) def test_orct123Reversible(self): bayer = cv2.imread("../Data/image.bmp") bayer = np.sum(bayer, axis=2).astype('float64') orct1Filtered = compute_orct1V2(bayer, precisionFloatingPoint=self.precisionFloatingPoint) orct23Filtered = compute_orct2plus3(orct1Filtered, precisionFloatingPoint=self.precisionFloatingPoint) orct23FilteredNormalized = copy.deepcopy(orct23Filtered) orct23FilteredNormalized[orct23FilteredNormalized == 0] = -256 orct23FilteredNormalized = (orct23FilteredNormalized + 256) / 2 orct23FilteredNormalized = np.ceil(orct23FilteredNormalized) orct23FilteredNormalized = orct23FilteredNormalized * 2 - 256 orct23FilteredNormalized[orct23FilteredNormalized == -256] = 0 orct23Filtered = orct23FilteredNormalized orct23FilteredInversed = compute_orct2plus3inverse(orct23Filtered, precisionFloatingPoint=self.precisionFloatingPoint) orct1FilteredInversed = compute_orct1inverseV2(orct23FilteredInversed, precisionFloatingPoint=self.precisionFloatingPoint) print("PSNR: {}".format(self.evaluation.calculate_psnr(np.round(orct23FilteredInversed), np.round(orct1Filtered)))) print("PSNR: {}".format(self.evaluation.calculate_psnr(bayer, np.round(orct1FilteredInversed)))) def test_orct12(self): bayer = self.datasetUtils.readCFAImages() bayer = bayer.astype("float64") orct1Res = compute_orct1(bayer, precisionFloatingPoint=self.precisionFloatingPoint) filtered = compute_orct2(orct1Res, precisionFloatingPoint=self.precisionFloatingPoint) # filtered = (filtered)/2 filtered[filtered == 0] = -256 filtered = (filtered + 256) / 2 def inverseFunction(data): data = data.astype('float32') data = data * 2 - 256 data[data == -256] = 0 data = compute_orct2inverse(data, precisionFloatingPoint=self.precisionFloatingPoint) data = compute_orct1inverse(data, precisionFloatingPoint=self.precisionFloatingPoint) return data sampleFunctionReverse = inverseFunction self.evaluation.evaluate(filtered, bayer, sampleFunctionReverse, precisionFloatingPoint=self.precisionFloatingPoint) pass def test_orct123Plus(self): bayer = self.datasetUtils.readCFAImages() bayer = bayer.astype("float32") orct_1 = compute_orct1V2(bayer, precisionFloatingPoint=self.precisionFloatingPoint) filtered = compute_orct2plus3(orct_1, precisionFloatingPoint=self.precisionFloatingPoint) filtered[filtered == 0] = -256 filtered = (filtered + 256) / 2 filtered = np.ceil(filtered) def inverseFunction(data): data = data.astype('float32') data = data * 2 - 256 data[data == -256] = 0 data = compute_orct2plus3inverse(data, precisionFloatingPoint=self.precisionFloatingPoint) data = compute_orct1inverseV2(data, precisionFloatingPoint=self.precisionFloatingPoint) return np.round(data) sampleFunctionReverse = inverseFunction self.evaluation.evaluate(filtered, bayer, sampleFunctionReverse, precisionFloatingPoint=self.precisionFloatingPoint, roundingMethod="ceil") pass def test_ocrtShahedWithDataset(self): rgbImages = self.datasetUtils.loadArri() cfaImages, image_size = self.datasetUtils.convertDatasetToCFA(rgbImages) psnrs = [] ssims = [] jpeg2000CompressionRatioAfters = [] JpegLsCompressionRatios = [] compressionRatioLZWs = [] compressionRatiojpeg2000LossyAfters = [] # filtered = (filtered + 128) # filtered[:, 1::2] = filtered[:, 1::2] / 2 + 128 def inverseFunction(data): data = data.astype('float32') * 2 - 256 data = compute_orct1inverse(data, precisionFloatingPoint=self.precisionFloatingPoint) return data sampleFunctionReverse = inverseFunction for bayer in cfaImages: bayer = bayer.astype("float32") filtered = compute_orct2(compute_orct1(bayer, precisionFloatingPoint=self.precisionFloatingPoint), precisionFloatingPoint=self.precisionFloatingPoint) test_sample = filtered filtered = (filtered + 256) / 2 psnr, ssim, jpeg2000CompressionRatioAfter, JpegLsCompressionRatio, compressionRatioLZWAfter, compressionRatiojpeg2000LossyAfter = self.evaluation.evaluate(filtered, bayer, sampleFunctionReverse, precisionFloatingPoint=self.precisionFloatingPoint) psnrs.append(psnr) ssims.append(ssim) jpeg2000CompressionRatioAfters.append(jpeg2000CompressionRatioAfter) JpegLsCompressionRatios.append(JpegLsCompressionRatio) compressionRatioLZWs.append(compressionRatioLZWAfter) compressionRatiojpeg2000LossyAfters.append(compressionRatiojpeg2000LossyAfter) pd.DataFrame({"psnr": psnrs, "ssim": ssims, "jpeg200CompressionRatio (bpp)": jpeg2000CompressionRatioAfters, "JpegLsCompressionRatio": JpegLsCompressionRatios, "compressionRatioLZW": compressionRatioLZWs, "compressionRatiojpeg2000Lossy": compressionRatiojpeg2000LossyAfters}).to_excel("resultsShahedMethod.xlsx") def test_ocrtNewMethodWithDataset(self): psnrs = [] ssims = [] jpeg2000CompressionRatioAfters = [] JpegLsCompressionRatiosAfters = [] compressionRatioLZWsAfters = [] jpeg2000CompressionRatioBefores = [] JpegLsCompressionRatiosBefores = [] compressionRatioLZWsBefores = [] datasetName = [] nameOfdatasets = ["Akademie", "Arri exterior", "Color test chart", "Face", "Kodak", "Lake locked", "Lake pan", "Night Odeplatz", "Nikon D40", "Nikon D90", "Nikon D7000", "Siegestor", "Pool interior"] for nameOfdataset in nameOfdatasets: print(nameOfdataset) if nameOfdataset in ["Kodak", "Nikon D90", "Nikon D7000", "Nikon D40"]: self.precisionFloatingPoint = 0 bias = 256 else: self.precisionFloatingPoint = 4 bias = 65536 rgbImages = self.datasetUtils.loadOtherDataset(nameOfdataset) cfaImages, image_size = self.datasetUtils.convertDatasetToCFA(rgbImages) def inverseFunction(data): data = data.astype('float32') data = data * 2 - bias data = compute_orct2plus3inverse(data, precisionFloatingPoint=self.precisionFloatingPoint) data = compute_orct1inverseV2(data, precisionFloatingPoint=self.precisionFloatingPoint) return np.round(data) sampleFunctionReverse = inverseFunction for bayer in cfaImages: bayer = bayer.astype("float32") filtered = compute_orct2plus3(compute_orct1(bayer, precisionFloatingPoint=self.precisionFloatingPoint), precisionFloatingPoint=self.precisionFloatingPoint) test_sample = filtered filtered = (filtered + bias) / 2 filtered = np.ceil(filtered-np.min(filtered)) psnr, ssim, jpeg2000CompressionRatioAfter, JpegLsCompressionRatioAfter, compressionRatioLZWAfter, jpeg2000CompressionRatioBefore, JpegLsCompressionRatioBefore, compressionRatioLZWBefore = self.evaluation.evaluate( filtered, bayer, sampleFunctionReverse, precisionFloatingPoint=self.precisionFloatingPoint, roundingMethod="ceil") datasetName.append(nameOfdataset) psnrs.append(psnr) ssims.append(ssim) jpeg2000CompressionRatioAfters.append(jpeg2000CompressionRatioAfter) JpegLsCompressionRatiosAfters.append(JpegLsCompressionRatioAfter) compressionRatioLZWsAfters.append(compressionRatioLZWAfter) jpeg2000CompressionRatioBefores.append(jpeg2000CompressionRatioBefore) JpegLsCompressionRatiosBefores.append(JpegLsCompressionRatioBefore) compressionRatioLZWsBefores.append(compressionRatioLZWBefore) pd.DataFrame({"Image set name": datasetName, "psnr": psnrs, "ssim": ssims, "jpeg200-LS After": jpeg2000CompressionRatioAfters, "jpeg-Ls After": JpegLsCompressionRatiosAfters, "LZW After": compressionRatioLZWsAfters, "jpeg200-LS Before": jpeg2000CompressionRatioBefores, "jpeg-Ls Before": JpegLsCompressionRatiosBefores, "LZW Before": compressionRatioLZWsBefores}).to_excel("resultsAll2.xlsx") def test_simpleORCT(self): bayer = np.array([[145, 77, 142, 73], [76, 67, 72, 62], [127, 67, 125, 65], [65, 54, 65, 57], [145, 75, 142, 73], [46, 61, 72, 62], [117, 47, 105, 65], [87, 31, 53, 17]]) bayer = bayer.astype("float32") data = compute_orct2plus3(bayer) data2 = compute_orct2plus3inverse(data) pass
class CreateBotFeatureTests(BaseTest): def __init__(self, *args, **kwargs): super(CreateBotFeatureTests, self).__init__(*args, **kwargs) self.__data = DataGenerateUtils() self.__login = LoginPage() self.__create_bot = CreateBotPage() self.__register = RegisterPage() self.__appearance = AppearancePage() self.__create_bot_validation = CreateBotValidation() self.__drop_down_list = DropDownList() self.__data_set = DataUtils() self.valid_email = self.__data.create_email() self.valid_username = self.__data.create_name() self.valid_password = self.__data.create_password() self.faq_url = YAML_CONFIG.get("stub_faq_url") def setUp(self): super().setUp() self.__register.open_register_page() self.__register.login_with_new_account(self.valid_username, self.valid_email, self.valid_password) self.__create_bot.wait_for_create_page() def test_create_bot_unsuccessfully_with_invalid_inputs(self): bot_infos = self.__data_set.get_data(INVALID_BOT_INFO_DATA) expected_errors = [bot_info[2] for bot_info in bot_infos[1:]] actual_errors = [] for bot_info in bot_infos[1:]: bot_name = bot_info[0] bot_url = bot_info[1] self.__create_bot.open_create_page() self.__create_bot.create_bot_with_data(bot_name, bot_url) actual_errors.append( self.__create_bot.lbl_error_message.get_element_text()) self.assertEqual(expected_errors, actual_errors) @unittest.skip("Update logic with ignore for offline network") def test_create_bot_unsuccessfully_with_offline_connection(self): DriverFactory.get_driver().core_driver.set_network_conditions( offline=True, latency=5, throughput=500 * 1024) self.__create_bot.open_create_page() self.__create_bot.create_bot_with_data('Random Name', 'www.katalon.com') self.assertEqual( self.__create_bot.lbl_error_message.get_element_text(), 'Failed to fetch') def test_create_bot_successfully(self): bot_name = "Bot_name" website = self.faq_url self.__create_bot.open_create_page() self.__create_bot.create_bot_with_data(bot_name, website) print(self.__appearance.get_header_title_text()) print(self.__appearance.get_expected_title(bot_name=bot_name)) assert self.__appearance.get_header_title_text( ) == self.__appearance.get_expected_title(bot_name=bot_name) self.__create_bot_validation.wait_and_verify_notification_message() self.__create_bot_validation.should_init_correct_total_faq_questions( self.valid_email, bot_name) self.__create_bot_validation.should_init_correct_question_data() def test_create_bot_with_existed_bot_name_successfully(self): new_bot_name = "Bot_name" new_bot_website = "www.google.com" # Create a bot self.test_create_bot_successfully() # Open create bot page again self.__create_bot.open_create_page() self.__create_bot.create_bot_with_data(new_bot_name, new_bot_website) # Verify that new bot name is displayed self.__create_bot_validation.new_bot_should_be_current_selected_bot( new_bot_name, new_bot_website) self.__create_bot_validation.wait_and_verify_notification_message() self.__create_bot_validation.should_init_correct_total_faq_questions( self.valid_email, new_bot_name) self.__create_bot_validation.should_init_correct_question_data() def test_create_bot_with_existed_website_successfully(self): new_bot_name = "Another name" new_bot_website = self.faq_url # Create a bot self.test_create_bot_successfully() # Open create bot page again self.__create_bot.open_create_page() self.__create_bot.create_bot_with_data(new_bot_name, new_bot_website) # Verify that new bot name is displayed self.__create_bot_validation.new_bot_should_be_current_selected_bot( new_bot_name, new_bot_website) self.__create_bot_validation.wait_and_verify_notification_message() self.__create_bot_validation.should_init_correct_total_faq_questions( self.valid_email, new_bot_name) self.__create_bot_validation.should_init_correct_question_data()