-
Notifications
You must be signed in to change notification settings - Fork 0
/
imageValues.pl
155 lines (140 loc) · 6.92 KB
/
imageValues.pl
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
% #############################################################
% # reads out image values that we use for feature extraction #
% #############################################################
:- dynamic imageFeature/3.
% for a given ImageId, calcualte the values and assert them
calculateImageValues(ImageId):-
% calculate image values
info("Calculate Image Values..."),
assertImageValuesForImageId(ImageId),
% do sobel convertion for sharpness detection
sobelEdgeDetection(ImageId,SobelImageId),
assertImageValuesForImageId(SobelImageId),
% use avgBrighness of sobel as sharpnessfactor
imageValue(SobelImageId,avgBrightness,SharpnessFactor),
assert(imageValue(ImageId,sharpness,SharpnessFactor)),
% remove sobel image from memory
deleteImage(SobelImageId),
% debug all image values
forall(imageValue(ImageId, Key, Value), debug(imageValues,imageValue(ImageId, Key, Value))).
assertImageValuesForImageId(ImageId):-
imageMeta(ImageId, _,_,Depth,_,TotalPixelCount),
% PREPAIR FACTS FOR ITERATION STEP
debug(imageValues,"Prepare Facts"),
assert(imageValue(ImageId,minBrightness,Depth)),
assert(imageValue(ImageId,maxBrightness,0)),
assert(imageValue(ImageId,totalR,0)),
assert(imageValue(ImageId,totalG,0)),
assert(imageValue(ImageId,totalB,0)),
% ITERATION STEP #1
debug(imageValues,"Start first iteration"),
!,forall(imagePixel(ImageId,H,W,R,G,B),
(!,
% MIN BRIGHTNESS
imageValue(ImageId,minBrightness,CurMinBrightness),!,
MinBrightness is floor((R+G+B) / 3),!,
NewMinBrightness is min(CurMinBrightness,MinBrightness),!,
retract(imageValue(ImageId,minBrightness,_)),!,
assert(imageValue(ImageId, minBrightness, NewMinBrightness)),!,
% MAX BRIGHTNESS
imageValue(ImageId,maxBrightness,CurMaxBrightness),!,
MaxBrightness is floor((R+G+B) / 3),!,
NewMaxBrightness is max(CurMaxBrightness,MaxBrightness),!,
retract(imageValue(ImageId,maxBrightness,_)),!,
assert(imageValue(ImageId, maxBrightness, NewMaxBrightness)),!,
% ADD TOTALS
imageValue(ImageId,totalR,CurR), NewR is CurR + R,!,
retract(imageValue(ImageId,totalR,_)),!,
assert(imageValue(ImageId, totalR, NewR)),!,
imageValue(ImageId,totalG,CurG), NewG is CurG + G,!,
retract(imageValue(ImageId,totalG,_)),!,
assert(imageValue(ImageId, totalG, NewG)),!,
imageValue(ImageId,totalB,CurB), NewB is CurB + B,!,
retract(imageValue(ImageId,totalB,_)),!,
assert(imageValue(ImageId, totalB, NewB)),!
)
),!,
debug(imageValues,"First iteration finished"),
debug(imageValues,"Start AvgCalculations"),
% AVERAGE CALCULATIONS
imageValue(ImageId,totalR,TotalR),
imageValue(ImageId,totalG,TotalG),
imageValue(ImageId,totalB,TotalB),
AvgR is TotalR / TotalPixelCount,
AvgG is TotalG / TotalPixelCount,
AvgB is TotalB / TotalPixelCount,
assert(imageValue(ImageId,avgR,AvgR)),
assert(imageValue(ImageId,avgG,AvgG)),
assert(imageValue(ImageId,avgB,AvgB)),
AvgBrightness is (AvgR+AvgG+AvgB) / 3,
assert(imageValue(ImageId, avgBrightness, AvgBrightness)),
% VARIANCE CALCULATIONS
% calc variance with two-pass algoritm
assert(imageValue(ImageId,stdSumR,0)),
assert(imageValue(ImageId,stdSumG,0)),
assert(imageValue(ImageId,stdSumB,0)),
assert(imageValue(ImageId,stdSumBrightness,0)),
debug(imageValues,"Second Iteration Started"),
!,
forall(imagePixel(ImageId,H,W,R,G,B),(!,
imageValue(ImageId, stdSumR, StdSumROld),!,
SdtSumRNew is StdSumROld + ((R-AvgR) * (R-AvgR)),!,
retract(imageValue(ImageId, stdSumR, _)),!,
assert(imageValue(ImageId, stdSumR, SdtSumRNew)),!,
imageValue(ImageId, stdSumG, StdSumGOld),!,
SdtSumGNew is StdSumGOld + ((G-AvgG) * (G-AvgG)),!,
retract(imageValue(ImageId, stdSumG, _)),!,
assert(imageValue(ImageId, stdSumG, SdtSumGNew)),!,
imageValue(ImageId, stdSumB, StdSumBOld),!,
SdtSumBNew is StdSumBOld + ((B-AvgB) * (B-AvgB)),!,
retract(imageValue(ImageId, stdSumB, _)),!,
assert(imageValue(ImageId, stdSumB, SdtSumBNew)),!,
imageValue(ImageId, stdSumBrightness, StdSumBrightnessOld),!,
Brigthness is floor((R+G+B)/3),!,
SdtSumBrightnessNew is StdSumBrightnessOld + ((Brigthness-AvgBrightness) * (Brigthness-AvgBrightness)),!,
retract(imageValue(ImageId, stdSumBrightness, _)),!,
assert(imageValue(ImageId, stdSumBrightness, SdtSumBrightnessNew)),!
)),!,
debug(imageValues,"Second Iteration Done"),
% calc std and variance
imageValue(ImageId, stdSumR, StdSumR),!,
StdR is StdSumR / (TotalPixelCount - 1), VarR is sqrt(StdR),!,
assert(imageValue(ImageId, stdR, StdR )),!,
assert(imageValue(ImageId, varR, VarR )),!,
imageValue(ImageId, stdSumG, StdSumG),!,
StdG is StdSumG / (TotalPixelCount - 1), VarG is sqrt(StdG),!,
assert(imageValue(ImageId, stdG, StdG )),!,
assert(imageValue(ImageId, varG, VarG )),!,
imageValue(ImageId, stdSumB, StdSumB),!,
StdB is StdSumB / (TotalPixelCount - 1), VarB is sqrt(StdB),!,
assert(imageValue(ImageId, stdB, StdB )),!,
assert(imageValue(ImageId, varB, VarB )),!,
imageValue(ImageId, stdSumBrightness, StdSumBrightness),!,
StdBrightness is StdSumBrightness / (TotalPixelCount - 1), VarBrightness is sqrt(StdBrightness),!,
assert(imageValue(ImageId, stdBrightness, StdBrightness )),!,
assert(imageValue(ImageId, varBrightness, VarBrightness )),
!.
% edge detection with sobel
% idea: https://medium.com/@enzoftware/how-to-build-amazing-images-filters-with-python-median-filter-sobel-filter-%EF%B8%8F-%EF%B8%8F-22aeb8e2f540
sobelEdgeDetection(ImageId,SobelImageId) :-
string_concat(ImageId,".sobel.ppm",SobelImageId),
copyImageMetaData(ImageId,SobelImageId),
forall(imagePixel(ImageId,H,W,R,G,B), sobelEdgeDetectionStep(imagePixel(ImageId,H,W,R,G,B),SobelImageId)).
% step that is performed on each pixel, can fail and goto default
sobelEdgeDetectionStep(imagePixel(ImageId,H,W,_,_,_),SobelImageId):-
imageMeta(ImageId, _,_,Depth,_,_),
pixelKernel(ImageId,H,W,RLT,GLT,BLT,RMT,GMT,BMT,RRT,GRT,BRT,
RLM,GLM,BLM,RRM,GRM,BRM,RLB,GLB,BLB,RMB,GMB,BMB,RRB,GRB,BRB),
LT is RLT+GLT+BLT,!, MT is RMT+GMT+BMT,!,
RT is RRT+GRT+BRT,!, LM is RLM+GLM+BLM,!,
RM is RRM+GRM+BRM,!, LB is RLB+GLB+BLB,!,
MB is RMB+GMB+BMB,!, RB is RRB+GRB+BRB,!,
Gx is (-LT) + (-MT - MT) + (-RT) + LB + (MB+MB) + RB,
Gy is (-LT) + RT + (-LM - LM) + (RM+RM) + (-LB) + RB,
Temp1 is Gx*Gx, Temp2 is Gy*Gy, Temp3 is Temp1 + Temp2,
Temp4 is sqrt(Temp3), Temp5 is Temp4 / 4328 * Depth,
Length is floor(Temp5),
assert(imagePixel(SobelImageId,H,W,Length,Length,Length)).
% we have no fail case here - so we need a fallback for the corner cases
sobelEdgeDetectionStep(imagePixel(_,H,W,_,_,_),SobelImageId) :-
assert(imagePixel(SobelImageId,H,W,0,0,0)).