def VerletAlgorithm(coords, vels, forces, M, delta_t, N):
"""
Algorithm to integrate Newtons equations of motion. Writes the results
of the calulcations in the requested format into an output file.
Parameters
----------
coords : numpy array
Array of the particle coordinates from the previous time step.
vels : numpy array
Array of the particle velocities from the previous time step.
forces : numpy array
Array of the particle forces from the previous time step.
M : int
Number of particles.
delta_t : float
Time step.
N : int
Number of iterations.
Returns
-------
None.
"""
filestring = Task2.createFilestring(M, L, coords, vels, "Time step 0")
for k in range(1, N):
coords = calculateNewCoords(coords, vels, forces, M, L, delta_t)
vels, forces = calculateNewVels(coords, vels, forces, M, L, delta_t)
filestring += Task2.createFilestring(M, L, coords, vels,
f"Time step {k}")
print(f"finished timestep {k}")
Task2.writeFile(filestring, "trajectories.txt")
def SplittingRecursive(image, left, right, top, bottom, depth=0):
cx, cy, n = Task2.FindCentroid(image, left, right, top, bottom)
if depth < 3:
SplittingRecursive(image, left, cx, top, cy, depth + 1) # Top Left
SplittingRecursive(image, cx, right, top, cy, depth + 1) # Bottom Left
SplittingRecursive(image, left, cx, cy, bottom, depth + 1) # Top Right
SplittingRecursive(image, cx, right, cy, bottom,
depth + 1) # Bottom Right
else:
rectangles.append([(left, top), (right, bottom)])
transitions.append(Task4.B2W_Transitions(image[top:bottom,
left:right]))
ratios.append(Task5.AspectRatio(left, right, top, bottom))
# Task 6
size = (bottom - top) * (right - left)
blacks = Task6.blackPixels(image, left, right, top, bottom)
try:
normalized.append(size / blacks)
except:
normalized.append(0)
cx, cy, n = Task2.FindCentroid(image[top:bottom, left:right], 0,
right - left, 0, bottom - top)
centroids.append((cx, cy))
# Task 7
angle = math.degrees(
math.acos(
(bottom - top - cy) / (math.sqrt((right - left - cx)**2 +
(bottom - top - cy)**2))))
angles.append(angle)
def VerletAlgorithm(coords, vels, forces, M, delta_t, N):
filestring = Task2.createFilestring(M, L, coords, vels, "Time step 0")
for k in range(1, N):
coords = calculateNewCoords(coords, vels, forces, M, L, delta_t)
vels, forces = calculateNewVels(coords, vels, forces, M, L, delta_t)
filestring += Task2.createFilestring(M, L, coords, vels,
f"Time step {k}")
print(f"finished timestep {k}")
Task2.writeFile(filestring, "trajectories.txt")
def SplittingRecursive(image, left, right, top, bottom, depth=0):
cx, cy = Task2.FindCentroid(image, left, right, top, bottom)
# print("(", top, "\t", left, ")\t(", bottom, "\t", right, ")\t", cx, "\t", cy, "\tDepth: ", depth)
if depth < 3:
SplittingRecursive(image, left, cy, top, cx, depth + 1) # Top Left
SplittingRecursive(image, cy, right, top, cx, depth + 1) # Bottom Left
SplittingRecursive(image, left, cy, cx, bottom, depth + 1) # Top Right
SplittingRecursive(image, cy, right, cx, bottom, depth + 1) # Bottom Right
else:
t = Task4.B2W_Transitions(image, left, right, top, bottom)
r = Task5.AspectRatio(left, right, top, bottom)
filePath = "../Text/"
# If Path Does not exists; Create it
if not os.path.exists(filePath):
os.makedirs(filePath + "Transitions/")
os.makedirs(filePath + "Ratios/")
os.makedirs(filePath + "Centroids/")
TransitionsFile = open(filePath + "Transitions/" + "signature.txt", "a")
TransitionsFile.write(str(t) + "\n")
TransitionsFile.close()
RatiosFile = open(filePath + "Ratios/" + "signature.txt", "a")
RatiosFile.write(str(r) + "\n")
RatiosFile.close()
CentroidsFile = open(filePath + "Centroids/" + "signature.txt", "a")
CentroidsFile.write(str(cx) + "," + str(cy) + "\n")
CentroidsFile.close()
return cv2.rectangle(bin_image, (top, left), (bottom, right), (0,255,0), 1)
def calculateNewVels(coords, vels, forces, M, L, delta_t):
"""
Calculates the velocities of the current time step.
Parameters
----------
coords : numpy array
Array of the particle coordinates from the current time step.
vels : numpy array
Array of the particle velocities from the previous time step.
forces : numpy array
Array of the particle forces from the current time step.
M : int
Number of particles.
L : float
Box side length.
delta_t : float
Time step.
Returns
-------
newVels : numpy array
Array of the particle velocities from the current time step.
newForces : numpy array
Array of the particle velocities from the next time step.
"""
newForces = Task2.calculateInitialForces(M, L, coords)
newVels = numpy.full_like(vels, 0.0) # numpy array allows updates
newVels[:][:] = vels[:][:] + \
0.5 * (forces[:][:] + newForces[:][:]) * delta_t
return newVels, newForces
def main():
global videoFileName
t2.main() # Call the main function of task-2
acceptInput() # Accepte User Input
# Open the input file to read
input_file = open(videoFileName, 'r')
frameInfo = input_file.readline()
rows = int(frameInfo.split(',')[0].split(':')[1].strip(' '))
cols = int(frameInfo.split(',')[1].split(':')[1].strip(' '))
wavelets = int(frameInfo.split((','))[2].split(':')[1].strip(' '))
computeEucleadean(input_file) #Compute Eculedean Distnace and similarities
input_file.close() #close the file
# Output
showFrames()
def main():
# Set sample video location to a default location
videoFilesPath = raw_input("Enter the path where the video files are: ")
videoFileName = raw_input("Enter the name of video file: ")
# create a videoInformationExtractor object
videoInformationExtractor = VideoInformationExtractor.TestVideoInformationExtractor(
videoFilesPath + "\\" + videoFileName)
videoInformationExtractor.videoInformation.dump(
videoFilesPath + "\\" + videoFileName.split(".")[0] + ".original")
while True:
# Accept feture number to be extracted from user
printLine()
print "Following options are available for feature extraction"
print "0. Exit"
print "1. Extract n-bin histogram for 8x8 pixel blocks"
print "2. Extract n most significant 2-D DCT components for 8x8 pixel blocks"
print "3. Extract n most significant 2-D DWT components for 8x8 pixel blocks"
print "4. Extract n-bin histogram for 8x8 pixel difference blocks"
print "5. Extract m most significant 2-D DWT components per frame"
feature = input("Enter option: ")
if feature == 0:
return
if feature == 1:
# Accept value n from user
n = input("Enter the value of n: ")
Task1a.extractFeature(videoInformationExtractor, videoFilesPath,
videoFileName, n)
if feature == 2:
# Accept value n from user
n = input("Enter the value of n: ")
blockLevel2DDCTExtractor = Task1b.BlockLevel2DDCTExtractor(
videoInformationExtractor, videoFilesPath, videoFileName, n)
blockLevel2DDCTExtractor.extractFeature()
if feature == 3:
# Accept value n from user
n = input("Enter the value of n: ")
blockLevel2DDWTExtractor = Task1c.BlockLevel2DDWTExtractor(
videoInformationExtractor, videoFilesPath, videoFileName, n)
blockLevel2DDWTExtractor.extractFeature()
if feature == 4:
# Accept value n from user
n = input("Enter the value of n: ")
Task1d.extractFeature(videoInformationExtractor, videoFilesPath,
videoFileName, n)
if feature == 5:
# Accept value n from user
m = input("Enter the value of m: ")
frameLevel2DDWTExtractor = Task2.FrameLevel2DDWTExtractor(
videoInformationExtractor, videoFilesPath, videoFileName, m)
frameLevel2DDWTExtractor.extractFeature()
def send_a_word(book_id, word):
if book_id == '1' or book_id == '2' or book_id == '3' or book_id == '4':
stemmer = SnowballStemmer('english') #intializing the stemmer
base_word = stemmer.stem(word) #stem the word that is comming
query = db.processed_text.find_one(
{'book_id': book_id}) #query if data present against the book_id
if query: #if something come in the response
if query[
"stemmed_words_count"]: # if stemmed_words_count dictionary is present in database
stemmed_words_count = json.loads(
query["stemmed_words_count"]
) #load the json of stemmed_words in the stemmed_words_count variable
return base_word + ":" + str(
stemmed_words_count.get(base_word, "Word not exists")
) #return the stemmed_word with its count
else: # if words_count is not present ,id database crashes so not create the collection again just update it
stemmed_words_count, stemmed_words = Task2.stemming(
) # calling function written in main.py to calculate the word_count with respect to book_id
updateQueryTask2(
book_id, stemmed_words, stemmed_words_count
) # updating words against book_id in the database so that next time no need to call the main function again
return base_word + ":" + str(
stemmed_words_count.get(base_word, "Word not exists")
) #return the stemmed_word with its count
else: #if the query is empty no document is present relative to the book id
stemmed_words_count, stemmed_words = Task2.stemming(
) #trigger the function in the task2 to get the stemmed words and stemmed words count
insetQueryTask2(
book_id, stemmed_words,
stemmed_words_count) #inset the document in the database
return base_word + ":" + str(
stemmed_words_count.get(base_word, "Word not exists")
) #return the stemmed_word with its count
return "Books only from 1 to 4"
def test_find_unique_classes(self):
columns = Task2.import_columns('sub_table.csv')
observed = Task2.find_unique_classes(columns['class'])
self.assertEqual(observed, {'Mammalia', 'Reptilia', 'Aves'})
def test_get_organism_with_longevity_morethan(self):
columns = Task2.import_columns('sub_table.csv')
observed = Task2.get_organism_with_longevity_morethan(columns['longevity_y'], long_y=150)
self.assertEqual(observed, [21255, 21265])
def calculateNewVels(coords, vels, forces, M, L, delta_t):
newForces = Task2.calculateInitialForces(M, L, coords)
newVels = numpy.full_like(vels, 0.0) # numpy array allows updates
newVels[:][:] = vels[:][:] + \
0.5 * (forces[:][:] + newForces[:][:]) * delta_t
return newVels, newForces
import Task1 import Task2 Task1.sets() Task1.sets() Task1.sets() Task1.sets() Task1.sets() print(Task2.gets())
# read command line params for stemmed data file
lstemmeddatafile = CACM_STEM_FILE + FILE_EXT
if len(input_arguments) > 2:
lstemmeddatafile = input_arguments[2]
# Tokenize raw text
tokenize_raw_data(ldatafilesdir)
# Write given queries to a file
create_directory(DIR_FOR_OUTPUT_FILES)
write_given_queries_to_file(
CACM_QUERY_FILE + FILE_EXT,
DIR_FOR_OUTPUT_FILES + "/" + FILE_FOR_QUERIES + FILE_EXT)
Task1.execute_system(ldatafilesdir)
Task2.execute_system(ldatafilesdir)
Task3A.execute_system(ldatafilesdir)
Task3B.execute_system(lstemmeddatafile)
ldictoffolderpaths = {}
ldictoffolderpaths[
1] = DIR_FOR_OUTPUT_FILES + "/" + TASK1_CONST + "/" + DIR_FOR_BM25_OUTPUT
ldictoffolderpaths[
2] = DIR_FOR_OUTPUT_FILES + "/" + TASK1_CONST + "/" + DIR_FOR_TFIDF_OUTPUT
ldictoffolderpaths[3] = LUCENE + "/" + LUCENE_RESULTS
ldictoffolderpaths[
4] = DIR_FOR_OUTPUT_FILES + "/" + TASK2_CONST + "/" + DIR_FOR_BM25_OUTPUT
ldictoffolderpaths[
5] = DIR_FOR_OUTPUT_FILES + "/" + TASK2_CONST + "/" + DIR_FOR_TFIDF_OUTPUT
ldictoffolderpaths[
6] = DIR_FOR_OUTPUT_FILES + "/" + TASK3A_CONST + "/" + DIR_FOR_BM25_OUTPUT
N : int
Number of iterations.
Returns
-------
None.
"""
filestring = Task2.createFilestring(M, L, coords, vels, "Time step 0")
for k in range(1, N):
coords = calculateNewCoords(coords, vels, forces, M, L, delta_t)
vels, forces = calculateNewVels(coords, vels, forces, M, L, delta_t)
filestring += Task2.createFilestring(M, L, coords, vels,
f"Time step {k}")
print(f"finished timestep {k}")
Task2.writeFile(filestring, "trajectories.txt")
if __name__ == "__main__":
from time import perf_counter
start = perf_counter()
path, delta_t, N = readInputArguments(sys.argv)
M, C, L, coords, vels = readFile(path)
forces = Task2.calculateInitialForces(M, L, coords)
VerletAlgorithm(coords, vels, forces, M, delta_t, N)
end = perf_counter()
print("execution time: ", end - start)
bin_image = Task0.Binarization(image, filename)
filename = filename.split('/')[-1]
# Task 1
height, width = bin_image.shape
filename = path + "box_" + filename
top, bottom, left, right = Task1.BoundingBox(bin_image, height, width)
bounding_box_image = cv2.rectangle(bin_image, (top, left), (bottom, right), (0,255,0), 3)
cv2.imwrite(filename, bounding_box_image)
B = (left, right, top, bottom)
filename = filename.split('/')[-1]
# Task 2
filename = path + "cen_" + filename
cx, cy = Task2.FindCentroid(bin_image, 0, bin_image.shape[1], 0, bin_image.shape[0])
centroid_image = cv2.circle(bounding_box_image, (cy, cx), 10, 200, -1)
cv2.imwrite(filename, centroid_image)
C = (cx, cy)
filename = filename.split('/')[-1]
# Task 3
filename = path + "seg_" + filename
top_left, bottom_left, top_right, bottom_right, segmented_image = Task3.DivideBoundingBox(centroid_image, top, bottom, left, right, cx, cy)
cv2.imwrite(filename, segmented_image)
filename = filename.split('/')[-1]
CleaningDirectories("../Text/")
image = SplittingRecursive(bin_image, left, right, top, bottom, 0)
cv2.imshow("image", image)
import Task1 import Task2 import Task3 # regression task task_1 = Task1.Task1() task_1.model_1_run() task_1.model_2_run() # multi-category task task_2 = Task2.Task2() task_2.model_1_run() task_2.model_2_run() # multi-label task task_3 = Task3.Task3() task_3.model_1_run() task_3.model_2_run()
# Task 0
filename = "bin_" + filename
bin_image = Task0.Binarization(image, filename)
# cv2.imshow("Binarization", bin_image)
# Task 1
width, height = bin_image.shape
filename = "box_" + filename
top, bottom, left, right, bounding_box_image = Task1.BoundingBox(width, height, bin_image, filename)
B = (left, right, top, bottom)
# cv2.imshow("Bounding Box", bounding_box_image)
# Task 2
filename = "cen_" + filename
centroid_image, cx, cy = Task2.FindCentroid(width, height, bin_image, bounding_box_image, filename)
C = (cx, cy)
# cv2.imshow("Centroid", centroid_image)
# Task 3
cx = int(cx)
cy = int(cy)
filename = "seg_" + filename
top_left, bottom_left, top_right, bottom_right, segmented_image = Task3.DivideBoundingBox(centroid_image, top, bottom, left, right, cx, cy, filename)
cv2.imshow("Top Left", top_left)
cv2.imshow("Bottom Left", bottom_left)
cv2.imshow("Top Right", top_right)
cv2.imshow("Bottom Right", bottom_right)
print("\nNumber of Black to White Transitions")
def main():
task = int(input("Input Task number:"))
if task == 1:
feature_model = int(
input("Select the Feature Model:\n1. CM\t2. LBP\t3. HOG\t4. SIFT : ")
)
dimension_reduction = int(
input(
"Select the Dimension Reduction Technique:\n1. PCA\t2. SVD\t3. NMF\t4. LDA : "
)
)
k = int(input("Enter k: "))
Task1.starter(feature_model, dimension_reduction, k)
elif task == 2:
choice = input(
"Do you want to go ahead with task 1 input configurations? yes(y) or no(n) "
)
image_id = input("Enter image ID: ")
m = int(input("Enter m: "))
feature_model = dimension_reduction = k = None
if choice == "n":
feature_model = int(
input("Select the Feature Model:\n1. CM\t2. LBP\t3. HOG\t4. SIFT : ")
)
dimension_reduction = int(
input(
"Select the Dimension Reduction Technique:\n1. PCA\t2. SVD\t3. NMF\t4. LDA : "
)
)
k = int(input("Enter k: "))
Task2.starter(feature_model, dimension_reduction, k, image_id, m)
elif task == 3:
feature_model = int(
input("Select the Feature Model:\n1. CM\t2. LBP\t3. HOG\t4. SIFT : ")
)
dimension_reduction = int(
input(
"Select the Dimension Reduction Technique:\n1. PCA\t2. SVD\t3. NMF\t4. LDA : "
)
)
k = int(input("Enter k: "))
label = int(
input(
"Select the label:\n1. Left\t2. Right\t3. Dorsal\t4. Palmar\n5. With accessories\t6. Without accessories\t7. Male\t8. Female: "
)
)
Task3.starter(feature_model, dimension_reduction, k, label)
elif task == 4:
choice = input(
"Do you want to go ahead with task 3 input configurations? yes(y) or no(n) "
)
image_id = input("Enter image ID: ")
m = int(input("Enter m: "))
feature_model = dimension_reduction = k = label = None
if choice == "n":
feature_model = int(
input("Select the Feature Model:\n1. CM\t2. LBP\t3. HOG\t4. SIFT : ")
)
dimension_reduction = int(
input(
"Select the Dimension Reduction Technique:\n1. PCA\t2. SVD\t3. NMF\t4. LDA : "
)
)
k = int(input("Enter k: "))
label = int(
input(
"Select the label:\n1. Left\t2. Right\t3. Dorsal\t4. Palmar\n5. With accessories\t6. Without accessories\t7. Male\t8. Female: "
)
)
Task4.starter(feature_model, dimension_reduction, k, label, image_id, m)
elif task == 5:
feature_model = int(
input("Select the Feature Model:\n1. CM\t2. LBP\t3. HOG\t4. SIFT : ")
)
dimension_reduction = int(
input(
"Select the Dimension Reduction Technique:\n1. PCA\t2. SVD\t3. NMF\t4. LDA : "
)
)
k = int(input("Enter k: "))
label = int(
input(
"Select the label:\n1. Left\t2. Right\t3. Dorsal\t4. Palmar\n5. With accessories\t6. Without accessories\t7. Male\t8. Female: "
)
)
image_id = input("Enter image ID: ")
Task5.starter(feature_model, dimension_reduction, k, label, image_id)
elif task == 6:
subject_id = int(input("Enter subject ID: "))
Task6.starter(subject_id)
elif task == 7:
k = int(input("Enter k: "))
Task7.starter(k)
elif task == 8:
k = int(input("enter k : "))
Task8.starter(k)
elif task == 9:
feature_model = int(
input("Select the Feature Model:\n1. CM\t2. LBP\t3. HOG\t4. SIFT : ")
)
dimension_reduction = int(
input(
"Select the Dimension Reduction Technique:\n1. PCA\t2. SVD\t3. NMF\t4. LDA : "
)
)
k = int(input("Enter k: "))
visualizer = int(input("Enter Visualizer:\n1. Data \t2.Feature "))
ExtraCredit.starter(feature_model, dimension_reduction, k, visualizer)
else:
print("Enter Task number (1-9)")
def test_count_no_of_species(self):
columns = Task2.import_columns('sub_table.csv')
observed = Task2.count_no_of_species(columns['species'])
self.assertEqual(observed, 21322)
def part_of_speech(book_id='all'):
if book_id == '1' or book_id == '2' or book_id == '3' or book_id == '4':
query = db.processed_text.find_one(
{'book_id': book_id}) #query if data present against the book_id
if query: #if something come in the response
if query["nouns"]: # if the response contains nouns
return query['total_verbs_nouns'] + " " + query[
'nouns'] + "verbs :" + query[
"verbs"] #the return the json of total nouns and verbs in the book and the nouns and the verbs
else: #if the query is empty no document is present relative to the book id
if query[
"stemmed_words_count"]: # if the stemmed words and count is present but the noun and verbs are not
stemmed_words_count = json.loads(
query["stemmed_words_count"]
) #just load the json into the dictionaries
stemmed_words = json.loads(
query["stemmed_words"]
) #just load the json into the dictionaries
nouns, verbs = Task3.part_of_speech(
stemmed_words, stemmed_words_count
) #trigger the function to find the nouns and verbs with the present stemmed words
total_noun_verbs = {
'total_nouns': len(nouns),
'total_verbs': len(verbs)
} #store the total nouns and total verbs in the seprate dictionary
updateQueryTask3(
book_id, nouns, verbs, total_noun_verbs, stemmed_words,
stemmed_words_count
) #update the document which already present with respective val
return json.dumps(total_noun_verbs) + json.dumps(
nouns
) + "verbs : " + json.dumps(
verbs
) #return the json of total nouns verbs, verbs and nouns
else: # when document is present but it neither contains nouns and verbs and stemmed word count and stemmed words
stemmed_words_count, stemmed_words = Task2.stemming(
book_id
) #tringger the task2 function to get the stemmed words and stemmed words count
nouns, verbs = Task3.part_of_speech(
stemmed_words, stemmed_words_count
) #tringger the task3 function to get the nouns ,verbs
total_noun_verbs = {
'total_nouns': len(nouns),
'total_verbs': len(verbs)
} #dictionary of total noun and total verbs
updateQueryTask3(
book_id, nouns, verbs, total_noun_verbs, stemmed_words,
stemmed_words_count
) #update the document with nouns,verbs,total noun verbs,stemmed words,stemmed words count
return json.dumps(
total_noun_verbs
) + "nouns :" + json.dumps(nouns) + "verbs : " + json.dumps(
verbs
) #return the json total_noun_verbs and nouns and verbs
else: # when no document present agains book_id
stemmed_words_count, stemmed_words = Task2.stemming(
book_id
) # trigger function to get the stemmed words and stemmed words count
# task3
nouns, verbs = Task3.part_of_speech(
stemmed_words, stemmed_words_count
) #trigger the function part of speech to get the nouns and verbs
total_noun_verbs = {
'total_nouns': len(nouns),
'total_verbs': len(verbs)
} #total verbs and total verbs
insetQueryTask3(
book_id, nouns, verbs, total_noun_verbs, stemmed_words,
stemmed_words_count) #insert and the data into the database
return json.dumps(total_noun_verbs) + "nouns:" + json.dumps(
nouns
) + "verbs : " + json.dumps(
verbs
) #return the json of nouns and verbs and total verbs and total nouns
elif book_id == 'all' or book_id == 'ALL':
list_of_all_books = ['1', '2', '3', '4'] #list of all books
my_dict_total_nv = {} # dictionary for total verbs and nouns
my_dict_total_n = {} #dictionay for nouns in each book
my_dict_total_v = {} #dictiony of verbs in each book
for book_no in list_of_all_books: #iterating through each book
query = db.processed_text.find_one(
{'book_id':
book_no}) #query if data present against the book_id
if query: #if something come in the response
if query["nouns"]: # if the response contains nouns
nouns = json.loads(
query["nouns"]
) #load the nouns in the nouns dictionary
verbs = json.loads(
query["verbs"]
) #load the verbs in the verbs dictionary
total_noun_verbs = json.loads(
query['total_verbs_nouns']
) #load the toatl nouns and berbs in the total_noun_verbs dictionary
else: # when the stemmed words and count is present but the noun and verbs are not
if query[
"stemmed_words_count"]: # if the stemmed words and count is present but the noun and verbs are not
stemmed_words_count = json.loads(
query["stemmed_words_count"]
) #just load the json into the dictionaries
stemmed_words = json.loads(
query["stemmed_words"]
) #just load the json into the dictionaries
nouns, verbs = Task3.part_of_speech(
stemmed_words, stemmed_words_count
) #trigger the function to find the nouns and verbs with the present stemmed words
total_noun_verbs = {
'total_nouns': len(nouns),
'total_verbs': len(verbs)
} #store the total nouns and total verbs in the seprate dictionary
updateQueryTask3(
book_no, nouns, verbs, total_noun_verbs,
stemmed_words, stemmed_words_count
) #update the document which already present with respective val
else: # when document is present but it neither contains nouns and verbs and stemmed word count and stemmed words
stemmed_words_count, stemmed_words = Task2.stemming(
book_no
) #tringger the task2 function to get the stemmed words and stemmed words count
nouns, verbs = Task3.part_of_speech(
stemmed_words, stemmed_words_count
) #tringger the task3 function to get the nouns ,verbs
total_noun_verbs = {
'total_nouns': len(nouns),
'total_verbs': len(verbs)
} #dictionary of total noun and total verbs
updateQueryTask3(
book_no, nouns, verbs, total_noun_verbs,
stemmed_words, stemmed_words_count
) #update the document with nouns,verbs,total noun verbs,stemmed words,stemmed words count
else: # when no document present agains book_id
stemmed_words_count, stemmed_words = Task2.stemming(
book_no
) # trigger function to get the stemmed words and stemmed words count
# task3
nouns, verbs = Task3.part_of_speech(
stemmed_words, stemmed_words_count
) #trigger the function part of speech to get the nouns and verbs
total_noun_verbs = {
'total_nouns': len(nouns),
'total_verbs': len(verbs)
} #total verbs and total verbs
insetQueryTask3(book_no, nouns, verbs, total_noun_verbs,
stemmed_words, stemmed_words_count
) #insert and the data into the database
my_dict_total_nv = Counter(my_dict_total_nv) + Counter(
total_noun_verbs
) #total_nouns and verbs in the all books will come in this dictionary
my_dict_total_n = Counter(my_dict_total_n) + Counter(
nouns) #total nouns of all books dictionary
my_dict_total_v = Counter(my_dict_total_v) + Counter(
verbs) #total verbs pf all books dictionary
return json.dumps(my_dict_total_nv) + "nouns :" + json.dumps(
my_dict_total_n) + " verbs " + json.dumps(
my_dict_total_v
) #return the json of total nouns ,verbs and total verbs nouns
return "task 3 Books only from 1 to 4"
def test_count_no_of_genus(self):
columns = Task2.import_columns('sub_table.csv')
observed = Task2.count_no_of_genus(columns['genus'])
self.assertEqual(observed, 4336)
# http://johnnyholland.org/wp-content/uploads/193383382_cf3b3bd6d0_o.png # Help on drawing: http://quickies.seriot.ch/index.php?id=256 ######################################## Task1.run(sessions, eventList, eyetrackList) ######################################################################################## # 2) Create an image for each 0.25 seconds and output them to a directory, # using FFMPEG or other lib to combine them all together into a movie. # Hint, create all images first then, in a separate step, call FFMPEG # to have it combine them itself. ######################################## Task2.run(sessions, eventList, eyetrackList) ######################################################################################## # 3) Identify the central point(s) of gaze over a period of time and # overlay a transparent white dot on the 1-3 areas of interest. # the number should depend on if everyone is looking in a single # place of if they are all looking in different places. # # Central points of gaze mean the "clusters" of gaze. If this doesn't make sense, please # ask for clarification or skip it. ######################################## # ...
def evaluate_all_systems(p_dictoffolderpaths, p_run_all_systems=True):
if p_run_all_systems:
Task1.execute_system('')
Task2.execute_system('')
Task3A.execute_system('')
Task3B.execute_system('')
print "Evaluating all systems..."
create_directory(ldirpath)
lquerydict = get_given_queries_in_dict(CACM_QUERY_FILE + FILE_EXT)
lquerydict = get_sorted_dict(lquerydict)
lallsystemsmeanvaluesdict = {}
lallsystemsavgprecisionvaluesdict = {}
for lkey, lvalue in p_dictoffolderpaths.iteritems():
lsystemname = get_system_name(lkey)
print "Evaluating system: " + lsystemname
lsystemmeanvaluesdict = {}
ldictofavgprecisionvalues = {}
llistofprecisionandrecallvalues = [
"Query Id,DocId,Rank,Precision,Recall"
]
llistofpatkvalues = ["Query Id,P@5,P@20"]
evaluate_system(
lvalue, # results folder path to evaluate
lquerydict, # dictionary containing all queries with query id
lsystemmeanvaluesdict, # dictionary to hold the mean values for all systems
ldictofavgprecisionvalues, # dictionary to hold avg precision values of systems
llistofprecisionandrecallvalues, # results of precision recall values for all queries
llistofpatkvalues # list to hold pat5 and pat20 values for all queries for this system
) # evaluate_system..
lallsystemsmeanvaluesdict[lkey] = lsystemmeanvaluesdict
# ldictofavgprecisionvalues = get_sorted_dict(ldictofavgprecisionvalues)
lallsystemsavgprecisionvaluesdict[lkey] = ldictofavgprecisionvalues
# print "Writing Precision and Recall values for system: " + lsystemname
llfilename = ldirpath + "/" + FILE_FOR_PRECISON_RECALL_RESULTS_OF_SYSTEM + "_" + lsystemname + CSV_FILE_EXT
create_file(llfilename, '')
convert_data_from_collection_to_file(llfilename,
llistofprecisionandrecallvalues)
# print "Writing P@5 and P@20 values for system: " + lsystemname
llfilename = ldirpath + "/" + FILE_FOR_PATK_RESULTS_OF_SYSTEM + "_" + lsystemname + CSV_FILE_EXT
create_file(llfilename, '')
convert_data_from_collection_to_file(llfilename, llistofpatkvalues)
# print "Writing mean values to file"
llistofmeanvalues = ["System,MAP,MRR,P@5,P@20"]
for lkey, lvalue in lallsystemsmeanvaluesdict.iteritems():
lsystemname = get_system_name(lkey)
lstr = lsystemname + "," + str(lvalue[MAP_CONST]) + "," + str(lvalue[MRR_CONST]) + \
"," + str(lvalue[PAT5_CONST]) + "," + str(lvalue[PAT20_CONST])
llistofmeanvalues.append(lstr)
lfilename = ldirpath + "/" + FILE_FOR_ALL_SYSTEMS_MEAN_VALUES + CSV_FILE_EXT
create_file(lfilename, '')
convert_data_from_collection_to_file(lfilename, llistofmeanvalues)
# print "Writing average precision values to file"
llistavgprecisionresults = ["System,Query Id,Average Precision"]
for lkey, lvalue in lallsystemsavgprecisionvaluesdict.iteritems():
lsystemname = get_system_name(lkey)
for ljkey, ljvalue in lvalue.iteritems():
lstr = lsystemname + "," + str(ljkey) + "," + str(ljvalue)
llistavgprecisionresults.append(lstr)
lfilename = ldirpath + "/" + FILE_FOR_ALL_SYSTEMS_AVG_PRECISION_VALUES + CSV_FILE_EXT
create_file(lfilename, '')
convert_data_from_collection_to_file(lfilename, llistavgprecisionresults)
# print "Run t-tests for models"
run_tests_for_models(lallsystemsavgprecisionvaluesdict, len(lquerydict))
def stemmed_lemmatized(book_id='all'):
if book_id == '1' or book_id == '2' or book_id == '3' or book_id == '4':
query = db.processed_text.find_one(
{'book_id': book_id}) #query if data present against the book_id
if query: #if something come in the response
if query[
"stemmed_words_count"]: # if the response contains the count of every stemmed_word
stemmed_words_count = query[
"stemmed_words_count"] #load the json of stemmed_words in the stemmed_words_count variable
return stemmed_words_count #return the stemmed_word_count json which has the words
else: # if document is present but there is value against words key
stemmed_words_count, stemmed_words = Task2.stemming(
book_id
) #trigger the function of to get the stemmed_words and stemmed words count
updateQueryTask2(
book_id, stemmed_words, stemmed_words_count
) # as the document present so just update the value against the book id words
return json.dumps(
stemmed_words_count) #return the json words json
else: #if the query is empty no document is present relative to the book id
stemmed_words_count, stemmed_words = Task2.stemming(
book_id
) #trigger the function in the task2 to get the stemmed words and stemmed words count
insetQueryTask2(
book_id, stemmed_words,
stemmed_words_count) #inset the document in the database
return json.dumps(
stemmed_words_count) #return the json of stemmed words count
elif book_id == 'all' or book_id == 'ALL':
my_dict = {
} #create the dictionary that will contain count all stemmed words
list_of_all_books = ['1', '2', '3', '4'] #list of all books ids
for book_no in list_of_all_books: #one by one iterating each book
query = db.processed_text.find_one(
{'book_id':
book_no}) #query if data present against the book_id
if query: #if something come in the response
if query[
"stemmed_words_count"]: # if the response contains the count of every stemmed_word
stemmed_words_count = json.loads(
query["stemmed_words_count"]
) #load the json of stemmed_words in the stemmed_words_count variable
else: #if the query is empty no document is present relative to the book id
stemmed_words_count, stemmed_words = Task2.stemming(
book_no
) #trigger the function of to get the stemmed_words and stemmed words count
updateQueryTask2(
book_no, stemmed_words, stemmed_words_count
) # as the document present so just update the value against the book id words
else: #if the query is empty no document is present relative to the book id
stemmed_words_count, stemmed_words = Task2.stemming(
book_no
) #trigger the function in the task2 to get the stemmed words and stemmed words count
insetQueryTask2(
book_no, stemmed_words,
stemmed_words_count) #inset the document in the database
my_dict = Counter(my_dict) + Counter(
stemmed_words_count
) #Counter will take the intersection of the keys that common and its values otherwise union
return json.dumps(my_dict) #return the json of stemmed words count
return "Books only from 1 to 4"
def run(sessions, eventList, eyetrackList):
print "Downloading session video for parsing..."
# download session video
opener = urllib2.build_opener(urllib2.HTTPHandler)
request = urllib2.Request("http://g3.eyetrackshop.com/content/" + eyetrackList[0]["ContentID"])
request.get_method = lambda: "GET"
url = opener.open(request)
tempdir = tempfile.tempdir = tempfile.mkdtemp()
movie = tempfile.NamedTemporaryFile(mode="w+", suffix=".mp4", delete=False)
movie.write(url.read())
moviename = movie.name
movie.close()
print "I've loaded it into:\n", moviename
# split apart session video into frame images
# ffmpeg -i inputfile.avi -r 12 -f image2 CT13C39DD417BLYWHILLT-SJJ-f%4d.jpeg
print "Using superhuman strength to split movie into images..."
movieframedir = tempdir + "/movieframes/"
os.mkdir(movieframedir)
args = {
"inputfile": moviename,
"framerate": 12,
"outputfilename":movieframedir + eyetrackList[0]["ContentID"] + "-f%4d.png"
}
command = "ffmpeg -i %(inputfile)s -r %(framerate)d -f image2 %(outputfilename)s" % args
ffmpeg_proc = subprocess.Popen(command, shell=True, bufsize= -1, stdout=subprocess.PIPE, stderr=subprocess.STDOUT)
io = ffmpeg_proc.communicate()
if not io[1] == None: pass # TODO: Automagically troubleshoot ffmpeg
print "Success! We have movie frames!\n", movieframedir
# generate gaze images
print "Generating Gaze Frames..."
gazedir = tempdir + "/gaze_frames/"
granule = 1000 / args["framerate"]
print granule
Task2.generateGazeFrames(eyetrackList, dirname=gazedir, granularity=granule)
print "Done Gazing into the gazes of others. See what I saw here:\n", gazedir
# add session frame images and gaze images together
# Image.composite(sessionframe, gazeimage, gazeimage)
print "Making composite frames..."
compdir = tempdir + "/composite_frames/"
os.mkdir(compdir)
i = 0
movieframelist = os.listdir(movieframedir)
gazeframelist = os.listdir(gazedir)
for gazeframename in gazeframelist:
movieframe = Image.open(movieframedir + movieframelist[i])
gazeframe = Image.open(gazedir + gazeframename)
# compimg = Image.composite(movieframe, gazeframe, gazeframe)
# compimg.save(compdir + str(i) + ".png", "PNG")
movieframe.paste(gazeframe, (0, 0), gazeframe)
movieframe.save(compdir + str(i) + ".png", "PNG")
i += 1
print "Done! Find your composite frames here:\n", compdir
# TODO: recomposite images into video
# ffmpeg -f image2 -r 4 -i CT13C39DD417BLYWHILLT-SJJ-gaze-comp-%4d.png -vcodec mpeg4 -r 30 CT13C39DD417BLYWHILLT-SJJ-gaze-overlay.mp4
args = {
"fps": 12,
"inputfilesmask": compdir + "%d.png",
"outputfilename": tempdir + "/" + eyetrackList[0]["ContentID"] + "-gaze_composite.mp4"
}
command = "ffmpeg -f image2 -r %(fps)d -i %(inputfilesmask)s -vcodec mpeg4 -r 30 %(outputfilename)s" % args
print("Now lets pull all those images into a movie for your gazing enjoyment")
# TODO: Figure out why making this movie hangs python...
# it's worked before. It only hangs sometimes. Memory issues? I think my machine has memory issues.
ffmpeg_proc = subprocess.Popen(command, shell=True, stdout=subprocess.PIPE, stderr=subprocess.STDOUT)
io = ffmpeg_proc.communicate()
print(io[0])
if not io[1] == None: print "Houston, we had a problem. with ffmpeg" # TODO: Automagically troubleshoot ffmpeg
else:
help='pure training')
parser.add_argument('--test', type=bool, default=False, help='test_phase')
parser.add_argument('--novel_path', type=str, help='training path')
#parser.add_argument('--train_path',type=str,default='task2-dataset/base',help='testing path')
parser.add_argument('--test_path', type=str, help='testing path')
parser.add_argument('--ensemble',
type=bool,
default=False,
help='ensemble?')
parser.add_argument('--way', type=bool, default=False, help='ensemble?')
parser.add_argument('--outfile', type=str, help='outfile_csv')
args = parser.parse_args()
print(args)
import Task2
model = Task2.Task2(args)
#print(args.train)
if args.train:
model.train()
elif args.test:
model.test()
else:
model.ensemble()
'''
import Task2_1
model = Task2_1.Task2(args)
if args.way:
model.train()
# This is a sample Python script.
import Task1, Task2, Task3, Task4, Task5, Task6, Task7, Task8, Task9, Task10, Task11, Task12
# Press the green button in the gutter to run the script.
if __name__ == '__main__':
print(" Enter first number : ")
inputNumber1 = int(input())
print(" Enter second number : ")
inputNumber2 = int(input())
# 1. Получить список всех нечётных чисел на отрезке [a, b].
print("<--------- Task 1 --------->")
print(Task1.getOddNumbersFromRange(inputNumber1, inputNumber2))
# 2. Получить список всех чисел Фибоначчи на отрезке [a, b].
print("<--------- Task 2 --------->")
print(Task2.cutByRangeFibonacci(inputNumber1, inputNumber2))
# 3. Напишите функцию, которая принимает на вход два параметра: a и b.
print("<--------- Task 3 --------->")
a = 12
b = "str"
print(" out parameters are : {a}, {b}".format(a = a, b = b))
Task3.functionInRequest(a, b)
# 4. Напишите функцию, которая принимает на вход три параметра
print("<--------- Task 4 --------->")
# # leap years
c = [1900, 1904, 1908, 1964, 2020]
startYear = 1900
finishYear = 2020
print(" our years' range : [ {s}, {f} ]".format(s = startYear, f = finishYear))
print(" exclude list from range : %s " % c )
print(Task4.listOfLeapYearsOnRange(startYear, finishYear, c))
# array for task 5-9
array = [1, "sd", 3, 1.2, 5.6, 0, -1]
def test_task2_zeroInFib(self):
self.assertTrue(0 not in Task2.cutByRangeFibonacci(0, 3))
def run(sessions, eventList, eyetrackList):
print "Downloading session video for parsing..."
# download session video
opener = urllib2.build_opener(urllib2.HTTPHandler)
request = urllib2.Request("http://g3.eyetrackshop.com/content/" +
eyetrackList[0]["ContentID"])
request.get_method = lambda: "GET"
url = opener.open(request)
tempdir = tempfile.tempdir = tempfile.mkdtemp()
movie = tempfile.NamedTemporaryFile(mode="w+", suffix=".mp4", delete=False)
movie.write(url.read())
moviename = movie.name
movie.close()
print "I've loaded it into:\n", moviename
# split apart session video into frame images
# ffmpeg -i inputfile.avi -r 12 -f image2 CT13C39DD417BLYWHILLT-SJJ-f%4d.jpeg
print "Using superhuman strength to split movie into images..."
movieframedir = tempdir + "/movieframes/"
os.mkdir(movieframedir)
args = {
"inputfile":
moviename,
"framerate":
12,
"outputfilename":
movieframedir + eyetrackList[0]["ContentID"] + "-f%4d.png"
}
command = "ffmpeg -i %(inputfile)s -r %(framerate)d -f image2 %(outputfilename)s" % args
ffmpeg_proc = subprocess.Popen(command,
shell=True,
bufsize=-1,
stdout=subprocess.PIPE,
stderr=subprocess.STDOUT)
io = ffmpeg_proc.communicate()
if not io[1] == None: pass # TODO: Automagically troubleshoot ffmpeg
print "Success! We have movie frames!\n", movieframedir
# generate gaze images
print "Generating Gaze Frames..."
gazedir = tempdir + "/gaze_frames/"
granule = 1000 / args["framerate"]
print granule
Task2.generateGazeFrames(eyetrackList,
dirname=gazedir,
granularity=granule)
print "Done Gazing into the gazes of others. See what I saw here:\n", gazedir
# add session frame images and gaze images together
# Image.composite(sessionframe, gazeimage, gazeimage)
print "Making composite frames..."
compdir = tempdir + "/composite_frames/"
os.mkdir(compdir)
i = 0
movieframelist = os.listdir(movieframedir)
gazeframelist = os.listdir(gazedir)
for gazeframename in gazeframelist:
movieframe = Image.open(movieframedir + movieframelist[i])
gazeframe = Image.open(gazedir + gazeframename)
# compimg = Image.composite(movieframe, gazeframe, gazeframe)
# compimg.save(compdir + str(i) + ".png", "PNG")
movieframe.paste(gazeframe, (0, 0), gazeframe)
movieframe.save(compdir + str(i) + ".png", "PNG")
i += 1
print "Done! Find your composite frames here:\n", compdir
# TODO: recomposite images into video
# ffmpeg -f image2 -r 4 -i CT13C39DD417BLYWHILLT-SJJ-gaze-comp-%4d.png -vcodec mpeg4 -r 30 CT13C39DD417BLYWHILLT-SJJ-gaze-overlay.mp4
args = {
"fps":
12,
"inputfilesmask":
compdir + "%d.png",
"outputfilename":
tempdir + "/" + eyetrackList[0]["ContentID"] + "-gaze_composite.mp4"
}
command = "ffmpeg -f image2 -r %(fps)d -i %(inputfilesmask)s -vcodec mpeg4 -r 30 %(outputfilename)s" % args
print(
"Now lets pull all those images into a movie for your gazing enjoyment"
)
# TODO: Figure out why making this movie hangs python...
# it's worked before. It only hangs sometimes. Memory issues? I think my machine has memory issues.
ffmpeg_proc = subprocess.Popen(command,
shell=True,
stdout=subprocess.PIPE,
stderr=subprocess.STDOUT)
io = ffmpeg_proc.communicate()
print(io[0])
if not io[1] == None:
print "Houston, we had a problem. with ffmpeg" # TODO: Automagically troubleshoot ffmpeg
else:
print "Success! Your gaze movie is located here:\n", args[
"outputfilename"]
def test_task2_fibValueForOne(self):
self.assertTrue(1 in Task2.cutByRangeFibonacci(0, 3))
# gradient. # It should look roughly like this, but without the web page: # http://johnnyholland.org/wp-content/uploads/193383382_cf3b3bd6d0_o.png # Help on drawing: http://quickies.seriot.ch/index.php?id=256 ######################################## Task1.run(sessions, eventList, eyetrackList) ######################################################################################## # 2) Create an image for each 0.25 seconds and output them to a directory, # using FFMPEG or other lib to combine them all together into a movie. # Hint, create all images first then, in a separate step, call FFMPEG # to have it combine them itself. ######################################## Task2.run(sessions, eventList, eyetrackList) ######################################################################################## # 3) Identify the central point(s) of gaze over a period of time and # overlay a transparent white dot on the 1-3 areas of interest. # the number should depend on if everyone is looking in a single # place of if they are all looking in different places. # # Central points of gaze mean the "clusters" of gaze. If this doesn't make sense, please # ask for clarification or skip it. ######################################## # ... ######################################################################################## # 3b) Create a separate movie showing this.
def test_get_organism_with_body_mass(self):
columns = Task2.import_columns('sub_table.csv')
observed = Task2.get_organism_with_body_mass(columns['adult_body_mass_g'], bm=114)
self.assertEqual(observed, [1342, 1645, 4309, 7329])
occ_total = {}
# declare a counter for loop control
count = 0
Task1.print_structure()
# combine the functions imported for Task2.py and Task3.py together,
# keep taking and processing the user input until the input is an empty string
while True:
# for the first loop (count = 0),
# assign the return value of Task2.take_input (should just be an input from user)
# to "user_input" variable for later use
if count == 0:
user_input = Task2.take_input()
# for later loops (count > 0), break the loop if the user input is empty
elif count > 0 and user_input == "":
break
# keep taking user input if its not empty
else:
user_input = Task2.take_input()
# check if user input is empty string,
# stop the loop if it is
if user_input == "":
break
# if user input is not empty string,
tasks=['1a', '1b', '1c', '1d', '2']
a_outFileName='{0}_hist_{1}.hst'.format(videoFileName,numOfBits)
b_outFileName = '{0}_blockdct_{1}.bct'.format(videoFileName, numOfBits)
c_outFileName = '{0}_blockdwt_{1}.bwt'.format(videoFileName, numOfBits)
d_outFileName='{0}_diff_{1}.dhc'.format(videoFileName,numOfBits)
Task1.extract_video_portion(fullPath, width, height, numOfBits, a_outFileName,b_outFileName,c_outFileName,d_outFileName)
for index, task_name in enumerate(tasks):
if task_name == '1a':
sorted_similarity=getSimilarFrames(a_outFileName,frameId)
visualizeFrames(fullPath, sorted_similarity, frameId,"Task1a")
elif task_name == '1b':
sorted_similarity=getSimilarFrames(b_outFileName, frameId)
visualizeFrames(fullPath, sorted_similarity, frameId, "Task1b")
elif task_name == '1c':
sorted_similarity=getSimilarFrames(c_outFileName, frameId)
visualizeFrames(fullPath, sorted_similarity, frameId, "Task1c")
elif task_name == '1d':
sorted_similarity=getSimilarFramesForDiffQuantization(d_outFileName,fullPath,frameId,width,height,numOfBits)
visualizeFrames(fullPath, sorted_similarity, frameId, "Task1d")
elif task_name == '2':
outFileName = getOutFileName(videoFileName, numOfBits, numOfSignComp, task_name)
Task2.extract_video(fullPath, numOfSignComp, outFileName)
sorted_similarity=getSimilarFrames(outFileName, frameId)
visualizeFrames(fullPath, sorted_similarity, frameId, "Task2")
c = cv2.waitKey(0)
if 'q' == chr(c & 255):
cv2.destroyAllWindows()