├── bright.circom ├── crop.circom ├── gen.py ├── no_round.circom ├── resize.circom ├── round.circom └── squares.circom /bright.circom: -------------------------------------------------------------------------------- 1 | pragma circom 2.0.0; 2 | 3 | 4 | template Num2Bits(n) { 5 | 6 | signal input in; 7 | 8 | signal output out[n]; 9 | 10 | var lc1=0; 11 | 12 | 13 | 14 | var e2=1; 15 | 16 | for (var i = 0; i> i) & 1; 19 | 20 | out[i] * (out[i] -1 ) === 0; 21 | 22 | lc1 += out[i] * e2; 23 | 24 | e2 = e2+e2; 25 | 26 | } 27 | 28 | 29 | lc1 === in; 30 | 31 | } 32 | 33 | template LessThan(n) { 34 | 35 | assert(n <= 252); 36 | 37 | signal input in[2]; 38 | 39 | signal output out; 40 | 41 | 42 | 43 | component n2b = Num2Bits(n+1); 44 | 45 | 46 | 47 | n2b.in <== in[0]+ (1< out; 76 | 77 | } 78 | 79 | template CheckBrightness() { 80 | signal input calcVal; 81 | signal input actualVal; 82 | signal input remainder; 83 | signal output out1; 84 | signal output out2; 85 | signal output out3; 86 | 87 | component lt1 = LessEqThan(13); 88 | component lt2 = LessEqThan(13); 89 | 90 | lt1.in[0] <== 2545; 91 | lt1.in[1] <== calcVal; 92 | out1 <== lt1.out * (actualVal - 255); 93 | 94 | lt2.in[0] <== calcVal; 95 | lt2.in[1] <== 5; 96 | out2 <== lt2.out * actualVal; 97 | 98 | var x = 1 - lt1.out - lt2.out; 99 | var y = 10 * actualVal - calcVal + remainder; 100 | out3 <== x * y; 101 | } 102 | 103 | 104 | template Bright(n) { 105 | 106 | signal input orig[n][3]; 107 | signal input new[n][3]; 108 | 109 | signal input positiveRemainder[n][3]; 110 | signal input negativeRemainder[n][3]; 111 | 112 | signal input alpha; 113 | signal input posBeta; 114 | signal input negBeta; 115 | 116 | signal output n_check; 117 | 118 | component checkBright[n][3]; 119 | 120 | signal test[n][3]; 121 | 122 | for (var i = 0; i < n; i++) { 123 | for (var j = 0; j < 3; j++) { 124 | checkBright[i][j] = CheckBrightness(); 125 | checkBright[i][j].calcVal <== alpha * orig[i][j] + posBeta - negBeta; 126 | checkBright[i][j].actualVal <== new[i][j]; 127 | checkBright[i][j].remainder <== positiveRemainder[i][j] - negativeRemainder[i][j]; 128 | 129 | checkBright[i][j].out1 === 0; 130 | checkBright[i][j].out2 === 0; 131 | checkBright[i][j].out3 === 0; 132 | } 133 | } 134 | 135 | 136 | n_check <== n; 137 | } 138 | 139 | component main = Bright(200); 140 | -------------------------------------------------------------------------------- /crop.circom: -------------------------------------------------------------------------------- 1 | pragma circom 2.0.0; 2 | 3 | template Crop(hOrig, wOrig, hNew, wNew, hStartNew, wStartNew) { 4 | 5 | signal input orig[hOrig][wOrig][3]; 6 | 7 | signal input new[hNew][wNew][3]; 8 | 9 | signal output n_check; 10 | 11 | 12 | for (var i = 0; i < hNew; i++) { 13 | 14 | for (var j = 0; j < wNew; j++) { 15 | 16 | for (var k = 0; k < 3; k++) { 17 | new[i][j][k] === orig[hStartNew + i][wStartNew + j][k]; 18 | } 19 | } 20 | } 21 | n_check <== 1; 22 | 23 | } 24 | 25 | 26 | 27 | component main = Crop(700, 700, 350, 350, 0, 0); 28 | -------------------------------------------------------------------------------- /gen.py: -------------------------------------------------------------------------------- 1 | import sys 2 | 3 | 4 | 5 | n = int(sys.argv[1]) 6 | 7 | 8 | 9 | print("{\"orig\": [") 10 | 11 | 12 | 13 | for i in range(0, n - 1): 14 | 15 | print("[150, 93, 200],[45, 239, 97],") 16 | 17 | 18 | 19 | print("[150, 93, 200],[45, 239, 97]") 20 | 21 | 22 | 23 | print("],") 24 | 25 | 26 | 27 | print("\"gray\" : [") 28 | 29 | 30 | 31 | for i in range(0, n - 1): 32 | 33 | print("122, 165,") 34 | 35 | 36 | 37 | print("122, 165") 38 | 39 | 40 | 41 | print("],") 42 | 43 | 44 | 45 | print("\"negativeRemainder\" : [") 46 | 47 | 48 | 49 | for i in range(0, n - 1): 50 | 51 | print("13, 0,") 52 | 53 | 54 | 55 | print("13, 0") 56 | 57 | 58 | 59 | print("],") 60 | 61 | 62 | 63 | print("\"positiveRemainder\" : [") 64 | 65 | 66 | 67 | for i in range(0, n - 1): 68 | 69 | print("0, 18,") 70 | 71 | 72 | 73 | print("0, 18") 74 | 75 | 76 | 77 | 78 | 79 | print("]}") 80 | 81 | 82 | -------------------------------------------------------------------------------- /no_round.circom: -------------------------------------------------------------------------------- 1 | pragma circom 2.0.0; 2 | 3 | 4 | 5 | 6 | template GrayscaleChecker(n) { 7 | 8 | signal input orig[n][3]; 9 | signal input gray[n]; 10 | signal input negativeRemainder[n]; 11 | signal input positiveRemainder[n]; 12 | 13 | signal output n_check; 14 | 15 | for (var i = 0; i < n; i++) { 16 | 30 * orig[i][0] + 59 * orig[i][1] + 11 * orig[i][2] === 100 * gray[i] - negativeRemainder[i] + positiveRemainder[i]; 17 | } 18 | 19 | 20 | n_check <== n; 21 | } 22 | 23 | component main = GrayscaleChecker(2); 24 | -------------------------------------------------------------------------------- /resize.circom: -------------------------------------------------------------------------------- 1 | pragma circom 2.0.0; 2 | 3 | 4 | 5 | 6 | 7 | template Resize(hOrig, wOrig, hNew, wNew) { 8 | 9 | 10 | 11 | signal input orig[hOrig][wOrig]; 12 | 13 | signal input new[hNew][wNew]; 14 | 15 | 16 | 17 | signal output n_check; 18 | 19 | 20 | 21 | for (var i = 0; i < hNew; i++) { 22 | 23 | for (var j = 0; j < wNew; j++) { 24 | 25 | 26 | 27 | var x_l = (wOrig - 1) * j / (wNew - 1); 28 | 29 | var y_l = (hOrig - 1) * i / (hNew - 1); 30 | 31 | var x_h = x_l * (wNew - 1) == (wOrig - 1) * j ? x_l : x_l + 1; 32 | 33 | var y_h = y_l * (hNew - 1) == (hOrig - 1) * i ? y_l : y_l + 1; 34 | 35 | 36 | 37 | var xRatioWeighted = ((wOrig - 1) * j) - (wNew - 1)*x_l; 38 | 39 | var yRatioWeighted = ((hOrig - 1) * i) - (hNew - 1)*y_l; 40 | 41 | 42 | 43 | var denom = (wNew - 1) * (hNew - 1); 44 | 45 | 46 | 47 | var sum = orig[y_l][x_l] * (wNew - 1 - xRatioWeighted) * (hNew - 1 - yRatioWeighted) 48 | 49 | + orig[y_l][x_h] * xRatioWeighted * (hNew - 1 - yRatioWeighted) 50 | 51 | + orig[y_h][x_l] * yRatioWeighted * (wNew - 1 - xRatioWeighted) 52 | 53 | + orig[y_h][x_h] * xRatioWeighted * yRatioWeighted; 54 | 55 | 56 | 57 | new[i][j] * denom === sum; 58 | 59 | 60 | 61 | } 62 | 63 | } 64 | 65 | 66 | 67 | n_check <== 1; 68 | 69 | 70 | 71 | } 72 | 73 | 74 | 75 | component main = Resize(3, 6, 3, 2); 76 | 77 | 78 | 79 | 80 | -------------------------------------------------------------------------------- /round.circom: -------------------------------------------------------------------------------- 1 | pragma circom 2.0.0; 2 | 3 | 4 | 5 | template Num2Bits(n) { 6 | signal input in; 7 | signal output out[n]; 8 | var lc1=0; 9 | var e2=1; 10 | 11 | for (var i = 0; i> i) & 1; 13 | out[i] * (out[i] -1 ) === 0; 14 | lc1 += out[i] * e2; 15 | e2 = e2+e2; 16 | 17 | } 18 | lc1 === in; 19 | } 20 | 21 | template LessThan(n) { 22 | assert(n <= 252); 23 | signal input in[2]; 24 | signal output out; 25 | 26 | component n2b = Num2Bits(n+1); 27 | 28 | n2b.in <== in[0]+ (1< out; 45 | } 46 | 47 | template GrayscaleChecker(n) { 48 | 49 | signal input orig[n][3]; 50 | 51 | signal input gray[n]; 52 | 53 | signal output n_check; 54 | 55 | component lt[n][2]; 56 | /* = LessEqThan(16); 57 | component lt2 = LessEqThan(16); 58 | */ 59 | for (var i = 0; i < n; i++) { 60 | var inter = 30 * orig[i][0] + 59 * orig[i][1] + 11 * orig[i][2]; 61 | 62 | lt[i][0] = LessEqThan(16); 63 | lt[i][1] = LessEqThan(16); 64 | 65 | lt[i][0].in[1] <== 100; 66 | lt[i][0].in[0] <== inter - 100 * gray[i]; 67 | lt[i][0].out === 1; 68 | 69 | lt[i][1].in[1] <== 100; 70 | lt[i][1].in[0] <== 100 * gray[i] - inter; 71 | lt[i][1].out === 1; 72 | } 73 | 74 | n_check <== n; 75 | } 76 | 77 | component main = GrayscaleChecker(8000); 78 | -------------------------------------------------------------------------------- /squares.circom: -------------------------------------------------------------------------------- 1 | pragma circom 2.0.0; 2 | 3 | 4 | template IsZero() { 5 | signal input in; 6 | signal output out; 7 | 8 | signal inv; 9 | 10 | inv <-- in!=0 ? 1/in : 0; 11 | out <== -in*inv + 1; 12 | in*out === 0; 13 | 14 | } 15 | 16 | template CheckBrightness() { 17 | signal input calcVal; 18 | signal input actualVal; 19 | signal input remainder; 20 | signal input x1; 21 | signal input x2; 22 | signal input x3; 23 | signal input x4; 24 | signal input x5; 25 | signal input x6; 26 | signal output out1; 27 | signal output out2; 28 | signal output out3; 29 | 30 | component isZero1 = IsZero(); 31 | isZero1.in <== 4 * (2545 - calcVal) + 1 - x1 - x2 - x3; 32 | out1 <== (1 - isZero1.out) * (actualVal - 255); 33 | 34 | component isZero2 = IsZero(); 35 | isZero2.in <== 4 * (calcVal - 5) + 1 - x4 - x5 - x6; 36 | out2 <== (1 - isZero2.out) * actualVal; 37 | 38 | var x = isZero1.out + isZero2.out - 1; 39 | var y = 10 * actualVal - calcVal + remainder; 40 | out3 <== x * y; 41 | } 42 | 43 | 44 | template Bright(n) { 45 | 46 | signal input orig[n][3]; 47 | signal input new[n][3]; 48 | signal input squares[n][3][6]; 49 | 50 | signal input positiveRemainder[n][3]; 51 | signal input negativeRemainder[n][3]; 52 | 53 | signal input alpha; 54 | signal input posBeta; 55 | signal input negBeta; 56 | 57 | signal output n_check; 58 | 59 | component checkBright[n][3]; 60 | 61 | for (var i = 0; i < n; i++) { 62 | for (var j = 0; j < 3; j++) { 63 | checkBright[i][j] = CheckBrightness(); 64 | checkBright[i][j].calcVal <== alpha * orig[i][j] + posBeta - negBeta; 65 | checkBright[i][j].actualVal <== new[i][j]; 66 | checkBright[i][j].remainder <== positiveRemainder[i][j] - negativeRemainder[i][j]; 67 | 68 | checkBright[i][j].x1 <== squares[i][j][0] * squares[i][j][0]; 69 | checkBright[i][j].x2 <== squares[i][j][1] * squares[i][j][1]; 70 | checkBright[i][j].x3 <== squares[i][j][2] * squares[i][j][2]; 71 | 72 | checkBright[i][j].x4 <== squares[i][j][3] * squares[i][j][3]; 73 | checkBright[i][j].x5 <== squares[i][j][4] * squares[i][j][4]; 74 | checkBright[i][j].x6 <== squares[i][j][5] * squares[i][j][5]; 75 | 76 | checkBright[i][j].out1 === 0; 77 | checkBright[i][j].out2 === 0; 78 | checkBright[i][j].out3 === 0; 79 | } 80 | } 81 | 82 | 83 | n_check <== n; 84 | } 85 | 86 | component main = Bright(2000); 87 | --------------------------------------------------------------------------------