from src.algorithms.BaseAlgorithm import fromDirectory
from src.algorithms.SURF import SURF
dataDir = "../../data"
partsDir = f"{dataDir}/parts/300x300"
originalDir = f"{dataDir}/original/300x300"
outputDir = f"{dataDir}/experimentResults/old_single/surf/new"
surf = SURF(parts=fromDirectory(partsDir), images=fromDirectory(originalDir))
surf.process()
surf.writeResults(outputDir)
surf.printResults()
"""
Results:
Total time [ms]: 460.539
Average times [ms]:
- Keypoint and descriptor computing for a part: 1.375
- Keypoint and descriptor computing for an image: 40.681
- Matching part with individual image: 0.425
- Matching part with all images: 4.273
- Processing entire part: 5.691
Average part descriptor size: 2936.89
Average image descriptor size: 39424.0
Deductions:
- almost identical implementation as SIFT
- similar times for computing the keypoints and descriptors
- matching and processing entire part is a lot faster in SURF
- this is most likely to much smaller descriptor size (and count)
print(
f"({strftime('%H:%M:%S')}) ({formatProgress(progress)}) Brightness: {formatPercentage(b)}, Contrast: {formatPercentage(c)}"
)
# preprocesses parts - changes brightness/contrast according to b or c
images = []
for path in paths:
img = cv.imread(path)
alpha = 1 + float(c) / 100
beta = float(b) / 100 * 255
# clips the values at 0 - 255, converts to unsigned ints (0 - 255)
image = InputImage(
np.asarray(np.clip(img * alpha + beta, 0, 255),
dtype=np.uint8), path)
images.append(image)
ft = FT(parts=images, images=fromDirectory(originalDir))
results = ft.process()
for i, result in enumerate(results):
_path = None
# finds correct result in annotations
annotatedResult = next(
x for x in annotations.matches
if x.part == os.path.basename(result.partPath))
if annotatedResult is None or os.path.basename(
result.imagePath) != annotatedResult.image:
_path = f"{outputDir}/nope/{formatFileName(i, b, c)}"
else:
_x, _y = result.start
distance = math.sqrt(
(_x - annotatedResult.x)**2 +
from src.algorithms.BaseAlgorithm import fromDirectory
from src.algorithms.FREAK import FREAK
dataDir = "../../data"
partsDir = f"{dataDir}/parts/300x300"
originalDir = f"{dataDir}/original/300x300"
outputDir = f"{dataDir}/experimentResults/old_single/fast_freak/new"
freak = FREAK(parts=fromDirectory(partsDir), images=fromDirectory(originalDir))
freak.process()
freak.writeResults(outputDir)
freak.printResults()
"""
Results:
Total time [ms]: 455.124
Average times [ms]:
- Keypoint and descriptor computing for a part: 1.634
- Keypoint and descriptor computing for an image: 21.735
- Matching part with individual image: 3.185
- Matching part with all images: 31.874
- Processing entire part: 33.557
Average part descriptor size: 9737.14
Average image descriptor size: 110316.8
Deductions:
- uses FAST keypoint detector and FREAK descriptor
- suffers from generally the same problem with FAST - small images
- didn't find any descriptors in the skyscraper part and the bridge part
- only found 1 descriptor in the cable car (part 3)?
from src.algorithms.BaseAlgorithm import fromDirectory
from src.algorithms.BRIEF import BRIEF
dataDir = "../../data"
partsDir = f"{dataDir}/parts/300x300"
originalDir = f"{dataDir}/original/300x300"
outputDir = f"{dataDir}/experimentResults/old_single/fast_brief/new"
brief = BRIEF(parts=fromDirectory(partsDir),
images=fromDirectory(originalDir))
brief.process()
brief.writeResults(outputDir)
brief.printResults()
"""
Results:
Total time [ms]: 230.885
Average times [ms]:
- Keypoint and descriptor computing for a part: 0.698
- Keypoint and descriptor computing for an image: 7.024
- Matching part with individual image: 2.554
- Matching part with all images: 25.561
- Processing entire part: 26.311
Average part descriptor size: 4229.33
Average image descriptor size: 51843.2
Deductions:
- uses FAST corner detector and BRIEF descriptor (neither can't be standalone)
- FAST produces keypoints, but doesn't have compute() method for descriptors
from src.algorithms.BaseAlgorithm import fromDirectory
from src.algorithms.ORB import ORB
dataDir = "../../data"
partsDir = f"{dataDir}/parts/300x300"
originalDir = f"{dataDir}/original/300x300"
outputDir = f"{dataDir}/experimentResults/old_single/orb/new"
orb = ORB(parts=fromDirectory(partsDir),
images=fromDirectory(originalDir))
orb.process()
orb.writeResults(outputDir)
orb.printResults()
"""
Results:
Total time [ms]: 240.82
Average times [ms]:
- Keypoint and descriptor computing for a part: 1.195
- Keypoint and descriptor computing for an image: 20.375
- Matching part with individual image: 0.694
- Matching part with all images: 6.953
- Processing entire part: 8.192
Average part descriptor size: 3288.0
Average image descriptor size: 13808.0
Deductions:
- similar results to FAST+BRIEF (which makes sense, since ORB builds on BOTH of them and improves their qualities)
- compared to FAST+BRIEF:
from src.algorithms.BaseAlgorithm import fromDirectory
from src.algorithms.HOG import HOG
dataDir = "../../data"
partsDir = f"{dataDir}/parts/300x300"
originalDir = f"{dataDir}/original/300x300"
outputDir = f"{dataDir}/experimentResults/old_single/hog/new"
hog = HOG(parts=fromDirectory(partsDir),
images=fromDirectory(originalDir))
hog.process()
hog.writeResults(outputDir)
hog.printResults()
"""
Results:
Total time [ms]: 7740.505
Average times [ms]:
- Descriptor computing for a part: 0.334
- Descriptor computing for a image: 5.248
- Matching part with individual image: 85.34
- Matching part with all images: 853.442
- Processing entire part: 853.887
Average part descriptor size: 14464.0
Average image descriptor size: 197136.0
Average subsets in image: 2967.11
Deductions:
- calculating descriptors with HOG is very quick
from src.algorithms.BaseAlgorithm import fromDirectory
from src.algorithms.FT import FT
dataDir = "../../data"
partsDir = f"{dataDir}/parts/300x300"
originalDir = f"{dataDir}/original/300x300"
outputDir = f"{dataDir}/experimentResults/old_single/ft/new"
ft = FT(parts=fromDirectory(partsDir), images=fromDirectory(originalDir))
ft.process()
ft.writeResults(outputDir)
ft.printResults()
"""
Results:
Total time [ms]: 872.91
Average times [ms]:
- Descriptor computing for a part: 0.673
- Descriptor computing for a image: 7.644
- Matching part with individual image: 8.757
- Matching part with all images: 87.593
- Processing entire part: 88.319
Average part descriptor size: 128.11
Average image descriptor size: 1444.0
Average subsets in image: 727.67
Deductions:
- comparing the results to HOG, since both of them sort of consider the picture as basically one giant keypoint:
- FT is much faster
- this is most likely to drastically smaller descriptor size and subset count
partsDir = f"{dataDir}/parts/{size}"
originalDir = f"{dataDir}/original/{size}"
outputDir = f"{dataDir}/experimentResults/{size}"
Algorithm = namedtuple("Algorithm", "name type output")
algorithms = [
Algorithm(name="FT", type=FT, output=f"{outputDir}/ft"),
Algorithm(name="SIFT", type=SIFT, output=f"{outputDir}/sift"),
Algorithm(name="SURF", type=SURF, output=f"{outputDir}/surf"),
Algorithm(name="BRIEF", type=BRIEF, output=f"{outputDir}/fast_brief"),
Algorithm(name="ORB", type=ORB, output=f"{outputDir}/orb"),
Algorithm(name="FREAK", type=FREAK, output=f"{outputDir}/fast_freak"),
Algorithm(name="HOG", type=HOG, output=f"{outputDir}/hog")
]
print(f"({strftime('%H:%M:%S')}) Started")
for a in algorithms:
print(f"({strftime('%H:%M:%S')}) Algorithm: {a.name}")
for i in range(10):
print(f"({strftime('%H:%M:%S')}) - Iteration {i + 1}")
obj = a.type(parts=fromDirectory(partsDir),
images=fromDirectory(originalDir),
iteration=i)
obj.process()
obj.writeResults(f"{a.output}/{i}", includePart=True)
obj.printResults(f"{a.output}/{i}_result.txt")
gc.collect()
print(f"({strftime('%H:%M:%S')}) Ended")
from src.algorithms.BaseAlgorithm import fromDirectory
from src.algorithms.SIFT import SIFT
dataDir = "../../data"
partsDir = f"{dataDir}/parts/300x300"
originalDir = f"{dataDir}/original/300x300"
outputDir = f"{dataDir}/experimentResults/old_single/sift/new"
sift = SIFT(parts=fromDirectory(partsDir), images=fromDirectory(originalDir))
sift.process()
sift.writeResults(outputDir)
sift.printResults()
"""
Results:
Total time [ms]: 618.98
Average times [ms]:
- Keypoint and descriptor computing for a part: 4.767
- Keypoint and descriptor computing for an image: 47.002
- Matching part with individual image: 1.141
- Matching part with all images: 11.429
- Processing entire part: 16.254
Average part descriptor size: 12458.67
Average image descriptor size: 74598.4
Deductions:
- compared to HOG, SIFT is much faster and I think it should be more robust
- after improving HOG, both pre-compute their descriptors, so the difference is most likely in the descriptor sizes
- average image descriptor for SIFT is 62.16 % smaller than HOG = that might be responsible for the 97.86 % speed increase over HOG
"""
