def main():
# Read two images. PLEASE provide complete path containing test_input folder
img_1 = input_image.input_im('test_input/1/01_1.bmp')
img_2 = input_image.input_im('test_input/1/01_10.bmp')
# Enhancing the image, followed by morphological operations.
img_skeleton_1 = image_enhancement.perform_enhancement_and_morphology(
img_1)
img_skeleton_2 = image_enhancement.perform_enhancement_and_morphology(
img_2)
# This step finds ridge bifurcations and endings. Descriptors are obtained for these minutiae points
kp1, des1 = descriptors.get_descriptors(img_skeleton_1)
kp2, des2 = descriptors.get_descriptors(img_skeleton_2)
# Displaying key points(ridge bifurcations and endings) on image
img4 = cv2.drawKeypoints(img_skeleton_1.astype('uint8') * 255,
kp1,
outImage=None)
img5 = cv2.drawKeypoints(img_skeleton_2.astype('uint8') * 255,
kp2,
outImage=None)
cv2.imshow("key points for img_1", img4)
cv2.imshow("key points for img_2", img5)
# Matching between descriptors
bf = cv2.BFMatcher(cv2.NORM_HAMMING, crossCheck=False)
matches = sorted(bf.match(des1, des2), key=lambda match: match.distance)
# Plot keypoints
# Plot matches
img3 = cv2.drawMatches(img_skeleton_1.astype('uint8') * 255,
kp1,
img_skeleton_2.astype('uint8') * 255,
kp2,
matches,
flags=2,
outImg=None)
cv2.imshow("matched image ", img3)
cv2.waitKey(0)
# Calculate score and display matching result.
score = 0
for match in matches:
score += match.distance
score_threshold = 33
print(score_threshold)
if score / len(matches) < score_threshold:
print("Fingerprint matches.")
else:
print("Fingerprint does not match.")
def parse(self, data, offset=0):
"""Parse the given data saving the service information
Parses the given data starting at the given offset to save the service information.
Once the parsing is complete the offset at which it was completed is returned. This
allows a loop to process a block of SDT service description data.
Arguments:
data -- array of data bytes to parse to build the elementary stream information
offset -- the byte offset at which to start the parsing (default 0)
Returns:
The byte offset at which this elementary stream data ends
"""
ln = len(data) - offset
if ln < 5: #TODO - add exception here
return None
self.service_id = (data[0+offset] << 8) + data[1+offset]
eit_flags = data[2+offset]
if eit_flags & (int('00000010', 2)):
self.eit_schedule_flag = True
if eit_flags & (int('00000001', 2)):
self.eit_present_following_flag = True
ca_rs_flags = data[3+offset]
self.running_status = ca_rs_flags & (int('11100000', 2))
self.running_status >>= 5
if ca_rs_flags & (int('00010000', 2)):
self.free_ca_mode = True
self.descriptors_len = ((data[3+offset] & int('00001111', 2)) << 8) + data[4+offset]
if self.descriptors_len + 5 > ln: #TODO - add exception here
return None
desc_data = data[5+offset:self.descriptors_len + 5 + offset]
self.descriptors = descriptors.get_descriptors(desc_data)
self.length = self.descriptors_len + 5
return self.descriptors_len + 5 + offset
def parse(self, data):
"""Parses the given data to generate all the Cat information
Given an array of bytes that comprise a CAT section, this method will parse and record all the section information
in object members. Inherits from Section.parse. Will call the Section.parse() method and once complete will parse
the section table_data to get the CAT specific information.
Arguments:
data -- Array of data bytes that describe all or part of the CAT section (default None)
"""
super(Cat, self).parse(data)
if self.complete:
self.payload = self.table_body[5:]
desc_data = self.payload[0:-4]
self.descriptors = descriptors.get_descriptors(desc_data)
del(self.payload)
def parse(self, data=None):
"""Parses the given data to generate all the BAT/NIT information
Given an array of bytes that comprise a BAT/NIT section, this method will parse and record all the section information
in object members. Inherits from Section.parse. Will call the Section.parse() method and once complete will parse
the section table_data to get the BAT/NIT specific information.
Arguments:
data -- Array of data bytes that describe all or part of the BAT/NIT section (default None)
"""
super(BatNitBase, self).parse(data)
if self.complete:
self.payload = self.table_body[5:]
self._get_descriptors_len()
desc_data = self.payload[2:2+self.descriptors_len]
self.descriptors = descriptors.get_descriptors(desc_data)
self._get_ts_loop_len()
self._get_ts_loop()
del(self.payload)
def parse(self, data):
"""Parses the given data to generate all the PMT information
Given an array of bytes that comprise a PMT section, this method will parse and record all the section information
in object members. Inherits from Section.parse. Will call the Section.parse() method and once complete will parse
the section table_data to get the PMT specific information.
Arguments:
data -- Array of data bytes that describe all or part of the PAT section (default None)
"""
super(Pmt, self).parse(data)
self.program_number = self.table_id_extension
if self.complete:
self.payload = self.table_body[5:]
self.pcr_pid = get_pcr_pid(self.payload)
self.program_info_length = get_program_info_length(self.payload)
self.program_info_data = get_program_info_data(self.payload)
self.descriptors = descriptors.get_descriptors(
self.program_info_data)
self._get_es_loop(self.payload)
del (self.payload)
def parse(self, data, offset):
"""Parse the given data saving the elementary stream information
Parses the given data starting at the given offset to save the elementary stream
information. Once the parsing is complete the offset at which it was completed is
returned. This allows a loop to process a block of PMT elementary stream data.
Arguments:
data -- array of data bytes to parse to build the elementary stream information
offset -- the byte offset at which to start the parsing
Returns:
The byte offset at which this elementary stream data ends
"""
self.stream_type = data[offset]
self.pid = data[offset + 1] & int('00011111', 2)
self.pid = self.pid << 8
self.pid = self.pid + data[offset + 2]
self.es_info_length = data[offset + 3] & int('00001111', 2)
self.es_info_length = self.es_info_length << 8
self.es_info_length = self.es_info_length + data[offset + 4]
self.es_data = data[offset + 5:offset + 5 + self.es_info_length]
self.descriptors = descriptors.get_descriptors(self.es_data)
return 5 + self.es_info_length
def parse(self, data, offset=0):
"""Parse the given data saving the Transport Stream information
Parses the given data starting at the given offset to save the TS information.
Once the parsing is complete the offset at which it was completed is returned. This
allows a loop to process a block of NIT/BAT TS loop data.
Arguments:
data -- array of data bytes to parse to build the transport stream information
offset -- the byte offset at which to start the parsing (default 0)
Returns:
The byte offset at which this transport stream data ends
"""
ln = len(data) - offset
if ln < 6:#TODO - exception here
return None
self.transport_stream_id = (data[0+offset] << 8) + data[1+offset]
self.original_network_id = (data[2+offset] << 8) + data[3+offset]
self.ts_descriptors_len = ((data[4+offset] & int('00001111', 2)) << 8) + data[5+offset]
if self.ts_descriptors_len + 6 > ln:#TODO - exception here
return None
desc_data = data[6+offset:self.ts_descriptors_len + 6 + offset]
self.descriptors = descriptors.get_descriptors(desc_data)
self.length = self.ts_descriptors_len + 6
return self.ts_descriptors_len + 6 + offset