summaryrefslogtreecommitdiff
path: root/utils/update-mojo.sh
blob: fcbc81e70529e008ebf6a43011ab6a2fc53eba37 (plain)
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
#!/bin/sh

# SPDX-License-Identifier: GPL-2.0-or-later
# Update mojo copy from a chromium source tree

if [ $# != 1 ] ; then
	echo "Usage: $0 <chromium dir>"
	exit 1
fi

ipc_dir="$(dirname "$(realpath "$0")")/ipc"
chromium_dir="$1"

if [ ! -d "${chromium_dir}/mojo" ] ; then
	echo "Directory ${chromium_dir} doesn't contain mojo"
	exit 1
fi

if [ ! -d "${chromium_dir}/.git" ] ; then
	echo "Directory ${chromium_dir} doesn't contain a git tree"
	exit 1
fi

# Get the chromium commit id
version=$(git -C "${chromium_dir}" rev-parse --short HEAD)

# Reject dirty trees
if [ -n "$(git -C "${chromium_dir}" status --porcelain)" ] ; then
	echo "Chromium tree in ${chromium_dir} is dirty"
	exit 1
fi

# Copy the diagnosis file
cp "${chromium_dir}/tools/diagnosis/crbug_1001171.py" "${ipc_dir}/tools/diagnosis"

# Copy the rest of mojo
cp "${chromium_dir}/mojo/public/LICENSE" "${ipc_dir}/mojo/public"

rm -rf "${ipc_dir}/mojo/public/tools/*"

(
	cd "${chromium_dir}" || exit
	find ./mojo/public/tools -type f \
	     -not -path "*/generators/*" \
	     -not -path "*/fuzzers/*" \
	     -exec cp --parents "{}" "${ipc_dir}" ";"
)

# Update the README files
readme=$(cat <<EOF
# SPDX-License-Identifier: CC0-1.0

Files in this directory are imported from ${version} of Chromium. Do not
modify them manually.
EOF
)

echo "$readme" > "${ipc_dir}/mojo/README"
echo "$readme" > "${ipc_dir}/tools/README"

cat <<EOF
------------------------------------------------------------
mojo updated. Please review and up-port local changes before
committing.
------------------------------------------------------------
EOF
decision boundary. """ geqs = np.array(sorted(geqs, key=lambda r: np.abs((r[1]-r[0])/r[0]))) length = len(geqs) g0 = geqs[length//2:, 0] g1 = geqs[length//2:, 1] gdiff = np.abs(g0-g1) """ find linear fit by minimising asymmetric least square errors in order to cover most of the macbeth images. the philosophy here is that every macbeth patch should fall within the threshold, hence the upper bound approach """ def f(params): m, c = params a = gdiff - (m*g0+c) """ asymmetric square error returns: 1.95 * a**2 if a is positive 0.05 * a**2 if a is negative """ return(np.sum(a**2+0.95*np.abs(a)*a)) initial_guess = [0.01, 500] """ Nelder-Mead is usually not the most desirable optimisation method but has been chosen here due to its robustness to undifferentiability (is that a word?) """ result = optimize.minimize(f, initial_guess, method='Nelder-Mead') """ need to check if the fit worked correectly """ if result.success: slope, offset = result.x Cam.log += '\nFit result: slope = {:.5f} '.format(slope) Cam.log += 'offset = {}'.format(int(offset)) """ optional plotting code """ if plot: x = np.linspace(max(g0)*1.1, 100) y = slope*x + offset plt.title('GEQ Asymmetric \'Upper Bound\' Fit') plt.plot(x, y, color='red', ls='--', label='fit') plt.scatter(g0, gdiff, color='b', label='data') plt.ylabel('Difference in green channels') plt.xlabel('Green value') """ This upper bound asymmetric gives correct order of magnitude values. The pipeline approximates a 1st derivative of a gaussian with some linear piecewise functions, introducing arbitrary cutoffs. For pessimistic geq, the model parameters have been increased by a scaling factor/constant. Feel free to tune these or edit the json files directly if you belive there are still mazing effects left (threshold too low) or if you think it is being overcorrected (threshold too high). We have gone for a one size fits most approach that will produce acceptable results in most applications. """ slope *= 1.5 offset += 201 Cam.log += '\nFit after correction factors: slope = {:.5f}'.format(slope) Cam.log += ' offset = {}'.format(int(offset)) """ clamp offset at 0 due to pipeline considerations """ if offset < 0: Cam.log += '\nOffset raised to 0' offset = 0 """ optional plotting code """ if plot: y2 = slope*x + offset plt.plot(x, y2, color='green', ls='--', label='scaled fit') plt.grid() plt.legend() plt.show() """ the case where for some reason the fit didn't work correctly Transpose data and then least squares linear fit. Transposing data makes it robust to many patches where green difference is the same since they only contribute to one error minimisation, instead of dragging the entire linear fit down. """ else: print('\nError! Couldn\'t fit asymmetric lest squares') print(result.message) Cam.log += '\nWARNING: Asymmetric least squares fit failed! ' Cam.log += 'Standard fit used could possibly lead to worse results' fit = np.polyfit(gdiff, g0, 1) offset, slope = -fit[1]/fit[0], 1/fit[0] Cam.log += '\nFit result: slope = {:.5f} '.format(slope) Cam.log += 'offset = {}'.format(int(offset)) """ optional plotting code """ if plot: x = np.linspace(max(g0)*1.1, 100) y = slope*x + offset plt.title('GEQ Linear Fit') plt.plot(x, y, color='red', ls='--', label='fit') plt.scatter(g0, gdiff, color='b', label='data') plt.ylabel('Difference in green channels') plt.xlabel('Green value') """ Scaling factors (see previous justification) The model here will not be an upper bound so scaling factors have been increased. This method of deriving geq model parameters is extremely arbitrary and undesirable. """ slope *= 2.5 offset += 301 Cam.log += '\nFit after correction factors: slope = {:.5f}'.format(slope) Cam.log += ' offset = {}'.format(int(offset)) if offset < 0: Cam.log += '\nOffset raised to 0' offset = 0 """ optional plotting code """ if plot: y2 = slope*x + offset plt.plot(x, y2, color='green', ls='--', label='scaled fit') plt.legend() plt.grid() plt.show() return round(slope, 5), int(offset) """" Return green channels of macbeth patches returns g0, g1 where > g0 is green next to red > g1 is green next to blue """ def geq(Cam, Img): Cam.log += '\nProcessing image {}'.format(Img.name) patches = [Img.patches[i] for i in Img.order][1:3] g_patches = np.array([(np.mean(patches[0][i]), np.mean(patches[1][i])) for i in range(24)]) Cam.log += '\n' return(g_patches)