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