8 | {
12 | alert(await file.text())
13 | }}
14 | />
15 |
16 | );
17 | }
18 | }
19 |
--------------------------------------------------------------------------------
/web/client/public/icon/unlock.svg:
--------------------------------------------------------------------------------
1 |
--------------------------------------------------------------------------------
/web/client/public/index.html:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 |
6 |
7 |
8 |
9 |
10 |
11 |
12 |
13 | Decode File
9 |
20 |
28 | );
29 | }
30 | }
31 |
--------------------------------------------------------------------------------
/web/client/package.json:
--------------------------------------------------------------------------------
1 | {
2 | "name": "neuralhash",
3 | "version": "0.1.0",
4 | "private": true,
5 | "dependencies": {
6 | "antd": "^3.2.1",
7 | "canny-edge-detector": "^1.0.0",
8 | "gsap": "^1.20.4",
9 | "html-to-react": "^1.3.3",
10 | "image-js": "^0.19.1",
11 | "imagetracerjs": "^1.2.3",
12 | "js-cookie": "^2.2.0",
13 | "jsfeat": "^0.0.8",
14 | "msqr": "^0.2.1",
15 | "react": "^16.2.0",
16 | "react-dom": "^16.2.0",
17 | "react-dropzone": "^4.2.8",
18 | "react-facebook-auth": "^1.3.0",
19 | "react-router": "^4.2.0",
20 | "react-router-transition": "^1.2.1",
21 | "react-scripts": "1.1.1",
22 | "svg-points": "^6.0.1"
23 | },
24 | "scripts": {
25 | "start": "react-app-rewired start",
26 | "build": "react-app-rewired build",
27 | "test": "react-app-rewired test --env=jsdom",
28 | "eject": "react-app-rewired eject"
29 | },
30 | "devDependencies": {
31 | "babel-plugin-import": "^1.6.4",
32 | "react-app-rewired": "^1.4.1"
33 | }
34 | }
35 |
--------------------------------------------------------------------------------
/web/client/src/components/UploadFile.js:
--------------------------------------------------------------------------------
1 | import React from "react";
2 | import { Upload, Icon } from "antd";
3 |
4 | export default class UploadFileComponent extends React.Component {
5 | render() {
6 | return (
7 | Facebook Auth
21 |
8 | {
14 | this.submit(info, this.props.data)
15 | return false;
16 | }}
17 | >
18 |
23 |
24 | );
25 | }
26 |
27 | submit = (file, data) => {
28 | let fileName = document.getElementById("file").files[0].name;
29 | let data = await fetch("http://localhost:5000/" + this.props.endpoint, {
30 | method: "POST",
31 | body: formData
32 | });
33 | this.props.onResponse(data, fileName);
34 | };
35 | }
36 |
--------------------------------------------------------------------------------
/web/client/src/pages/encode/EncodePage.js:
--------------------------------------------------------------------------------
1 | import React from "react";
2 | import UploadFileComponent from "../../components/UploadFile";
3 | import Cookies from "js-cookie";
4 |
5 | export default class EncodePage extends React.Component {
6 | render() {
7 | return (
8 |
19 |
Click or drag file a to upload
22 |
9 |
16 | );
17 | }
18 |
19 | downloadFile = (file, fileName) => {
20 | console.log("Starting timeout...");
21 | console.log(file);
22 | setTimeout(async () => {
23 | let a = document.createElement("a");
24 | document.body.appendChild(a);
25 | a.style = "display: none";
26 | let url = window.URL.createObjectURL(await file.blob());
27 | a.href = url;
28 | a.download = "protected_" + fileName;
29 | a.click();
30 | window.URL.revokeObjectURL(url);
31 | }, 2000);
32 | };
33 |
34 | handleFormChange(event) {
35 | this.setState({ value: event.target.value });
36 | }
37 | }
38 |
--------------------------------------------------------------------------------
/web/client/src/pages/select/SelectPage.js:
--------------------------------------------------------------------------------
1 | import React from "react";
2 | import "./select.css";
3 | import Link from "react-router-dom/Link";
4 | import { Button, Row, Col, Tooltip } from "antd";
5 | import TestMorph from '../../components/TestMorph'
6 |
7 | export default class SelectPage extends React.Component {
8 | state = {
9 | page: ""
10 | };
11 | render() {
12 | return (
13 | Sign File
10 |
14 |
15 |
19 |
25 |
26 |
27 |
28 |
32 |
38 |
39 |
40 |
41 |
42 |
43 | );
44 | }
45 | }
46 |
--------------------------------------------------------------------------------
/web/client/src/components/TestMorph.js:
--------------------------------------------------------------------------------
1 | import React from "react";
2 | import { Button } from "antd";
3 | import { TweenLite } from "gsap";
4 |
5 | export default class TestMorph extends React.Component {
6 | render() {
7 | return (
8 |
9 |
23 |
24 |
40 |
41 | );
42 | }
43 | }
44 |
--------------------------------------------------------------------------------
/web/client/src/pages/App.js:
--------------------------------------------------------------------------------
1 | import React, { Component } from "react";
2 | import AuthPage from "./auth/AuthPage";
3 | import SelectPage from "./select/SelectPage";
4 | import EncodePage from "./encode/EncodePage";
5 | import DecodePage from "./decode/DecodePage";
6 | import "./global.css";
7 | import Router from "react-router-dom/BrowserRouter";
8 | import { AnimatedSwitch, spring } from "react-router-transition";
9 | import Route from "react-router-dom/Route";
10 | import ImageTrace from '../components/ImageTrace/ImageTrace'
11 |
12 |
13 | function mapStyles(styles) {
14 | return {
15 | opacity: styles.opacity,
16 | transform: `scale(${styles.scale})`
17 | };
18 | }
19 |
20 | // wrap the `spring` helper to use a bouncy config
21 | function bounce(val) {
22 | return spring(val, {
23 | stiffness: 330,
24 | damping: 22
25 | });
26 | }
27 |
28 | class App extends Component {
29 | state = {
30 | page: "select"
31 | };
32 |
33 | render() {
34 | return (
35 |
36 |
37 |
53 |
59 |
60 |
61 | );
62 | }
63 | }
64 |
65 | export default App;
66 |
--------------------------------------------------------------------------------
/optimizers.py:
--------------------------------------------------------------------------------
1 |
2 | import numpy as np
3 | import random, sys, os, json, glob, math
4 |
5 | import IPython
6 |
7 | import torch
8 | import torch.nn as nn
9 | import torch.nn.functional as F
10 | import torch.optim as optim
11 | from torch.autograd import Variable
12 |
13 |
14 | class Optimizer(nn.Module):
15 | def __init__(self, parameters):
16 | self.parameters = parameters
17 | pass
18 |
19 | def step(self, loss):
20 | loss.backward(create_graph=True, retain_graph=True)
21 | for param in self.parameters:
22 | update = self.forward(param.grad, param)
23 | yield (param + update)
24 |
25 | def forward(self, grad, param=None):
26 | raise NotImplementedError()
27 |
28 |
29 | class Adam(Optimizer):
30 | def __init__(self, parameters, lr=1e-3, betas=(0.9, 0.999), eps=1e-8, differentiable=False):
31 |
32 | super().__init__(parameters)
33 |
34 | self.lr = lr
35 | self.betas = betas
36 | self.eps = eps
37 | self.state = {param: {} for param in parameters}
38 | self.differentiable = differentiable
39 |
40 | def forward(self, grad, param=None):
41 |
42 | state = self.state[param]
43 | step = state["step"] = state.get("step", 0) + 1
44 | exp_avg = state["exp_avg"] = state.get("exp_avg", torch.zeros_like(grad.data))
45 | exp_avg_sq = state["exp_avg_sq"] = state.get("exp_avg_sq", torch.zeros_like(grad.data))
46 | beta1, beta2 = self.betas
47 |
48 | exp_avg = exp_avg * beta1 + (1 - beta1) * (grad)
49 | exp_avg_sq = exp_avg_sq * (beta2) + (1 - beta2) * (grad) * (grad)
50 | denom = exp_avg_sq.sqrt() + self.eps
51 |
52 | bias_correction1 = 1 - beta1 ** state["step"]
53 | bias_correction2 = 1 - beta2 ** state["step"]
54 |
55 | step_size = self.lr * math.sqrt(bias_correction2) / bias_correction1
56 | update = -step_size * exp_avg / denom
57 |
58 | state["exp_avg"] = exp_avg.detach().data
59 | state["exp_avg_sq"] = exp_avg_sq.detach().data
60 |
61 | if not self.differentiable:
62 | update = update.data
63 |
64 | return update
65 |
--------------------------------------------------------------------------------
/run.py:
--------------------------------------------------------------------------------
1 |
2 | import random, sys, os, glob, yaml, time
3 | import argparse, subprocess, shutil, shlex
4 | from fire import Fire
5 | from utils import elapsed
6 |
7 | import IPython
8 |
9 |
10 | def execute(cmd, mode="experiment", config="default", shutdown=False, debug=False):
11 |
12 | elapsed()
13 | try:
14 | run_log = yaml.load(open("jobs/runlog.yml"))
15 | except:
16 | run_log = {}
17 |
18 | run_data = run_log[mode] = run_log.get(mode, {})
19 | run_data["runs"] = run_data.get("runs", 0) + 1
20 | run_name = mode + str(run_data["runs"])
21 | run_data[run_name] = run_data.get(run_name, {"config": config, "cmd": cmd, "status": "Running"})
22 | run_data = run_data[run_name]
23 |
24 | print(f"Running job: {run_name}")
25 |
26 | shutil.rmtree("output/", ignore_errors=True)
27 | os.makedirs("output/")
28 | os.makedirs(f"jobs/{run_name}", exist_ok=True)
29 |
30 | with open("jobs/jobinfo.txt", "w") as config_file:
31 | print(config, file=config_file)
32 |
33 | cmd = shlex.split(cmd)
34 | if cmd[0] == "python" and debug:
35 | cmd[0] = "ipython"
36 | cmd.insert(1, "-i")
37 | elif cmd[0] == "python":
38 | cmd.insert(1, "-u")
39 |
40 | print(" ".join(cmd))
41 | process = subprocess.Popen(cmd, shell=False, stdout=subprocess.PIPE, universal_newlines=True)
42 |
43 | try:
44 | with open(f"jobs/{run_name}/stdout.txt", "w") as outfile:
45 | for stdout_line in iter(process.stdout.readline, ""):
46 | print(stdout_line, end="")
47 | outfile.write(stdout_line)
48 |
49 | return_code = process.wait()
50 | run_data["status"] = "Error" if return_code else "Complete"
51 | except KeyboardInterrupt:
52 | print("\nKilled by user.")
53 | process.kill()
54 | run_data["status"] = "Killed"
55 | except OSError:
56 | print("\nSystem error.")
57 | process.kill()
58 | run_data["status"] = "Error"
59 |
60 | process.kill()
61 |
62 | if debug and run_data["status"] != "Complete":
63 | return
64 |
65 | shutil.copytree("output", f"jobs/{run_name}/output")
66 | for file in glob.glob("*.py"):
67 | shutil.copy(file, f"jobs/{run_name}")
68 |
69 | yaml.safe_dump(run_log, open("jobs/runlog.yml", "w"), allow_unicode=True, default_flow_style=False)
70 | yaml.safe_dump(run_data, open(f"jobs/{run_name}/comments.yml", "w"), allow_unicode=True, default_flow_style=False)
71 |
72 | interval = elapsed()
73 | print(f"Program ended after {interval:0.4f} seconds.")
74 | if shutdown and run_data["status"] != "Killed" and interval > 60:
75 | print(f"Shutting down in 1 minute.")
76 | time.sleep(60)
77 | subprocess.call("sudo shutdown -h now", shell=True)
78 |
79 |
80 | def run(cmd, mode="experiment", config="default", shutdown=False, debug=False):
81 | cmd = f""" screen -S {config} bash -c "python run.py execute \\"{cmd}\\" --mode {mode} --config {config} --shutdown {shutdown} --debug {debug}" """
82 | subprocess.call(shlex.split(cmd))
83 |
84 |
85 | if __name__ == "__main__":
86 | Fire({"run": run, "execute": execute})
87 |
--------------------------------------------------------------------------------
/old/train_dsc.py:
--------------------------------------------------------------------------------
1 |
2 | import numpy as np
3 | import random, sys, os, json, glob
4 | import tqdm, itertools, shutil
5 |
6 | import matplotlib as mpl
7 |
8 | mpl.use("Agg")
9 | import matplotlib.pyplot as plt
10 |
11 | import torch
12 |
13 | torch.backends.cudnn.benchmark = True
14 | import torch.nn as nn
15 | import torch.nn.functional as F
16 | import torch.optim as optim
17 | from torch.autograd import Variable
18 |
19 | from utils import *
20 | import transforms
21 | from modules import UNet
22 | from logger import Logger
23 |
24 | from sklearn.metrics import roc_auc_score
25 | from scipy.stats import pearsonr
26 | import IPython
27 |
28 | DATA_PATH = "data/encode_120"
29 | logger = Logger("train_dsc", ("loss", "corr"), print_every=5, plot_every=20)
30 |
31 |
32 | def loss_func(model, x, y):
33 | cleaned = model.forward(x)
34 | corr, p = pearsonr(
35 | cleaned.data.cpu().numpy().flatten(), y.data.cpu().numpy().flatten()
36 | )
37 | return (cleaned - y).pow(2).sum(), corr
38 |
39 |
40 | def data_gen(files, batch_size=64):
41 | while True:
42 | enc_files = random.sample(files, batch_size)
43 | orig_files = [f.replace("encoded", "original") for f in enc_files]
44 | print(enc_files)
45 | encoded_ims = [im.load(image) for image in enc_files]
46 | original_ims = [im.load(image) for image in orig_files]
47 | encoded, original = im.stack(encoded_ims), im.stack(original_ims)
48 |
49 | yield encoded, (encoded - original)
50 |
51 |
52 | def viz_preds(model, x, y):
53 | preds = model(x)
54 | for i, (pred, truth, enc) in enumerate(zip(preds, y, x)):
55 | im.save(im.numpy(enc), f"{OUTPUT_DIR}{i}_encoded.jpg")
56 | im.save(3 * np.abs(im.numpy(pred)), f"{OUTPUT_DIR}{i}_pred.jpg")
57 | im.save(3 * np.abs(im.numpy(truth)), f"{OUTPUT_DIR}{i}_truth.jpg")
58 |
59 |
60 | if __name__ == "__main__":
61 |
62 | model = nn.DataParallel(UNet())
63 | model.train()
64 |
65 | optimizer = torch.optim.Adam(model.parameters(), lr=1e-3)
66 |
67 | # optimizer.load_state_dict('output/unet_opt.pth')
68 | model.module.load("jobs/experiment_unet/output/train_unet.pth")
69 |
70 | logger.add_hook(
71 | lambda: [
72 | print(f"Saving model/opt to {OUTPUT_DIR}train_unet.pth"),
73 | model.module.save(OUTPUT_DIR + "train_unet.pth"),
74 | torch.save(optimizer.state_dict(), OUTPUT_DIR + "unet_opt.pth"),
75 | ],
76 | freq=100,
77 | )
78 |
79 | files = glob.glob(f"{DATA_PATH}/*encoded*.jpg")
80 | train_files, val_files = files[:-128], files[-128:]
81 | x_val, y_val = next(data_gen(val_files, 128))
82 |
83 | for i, (x, y) in enumerate(data_gen(train_files, 128)):
84 | loss, corr = loss_func(model, x, y)
85 |
86 | logger.step("loss", min(5000, loss))
87 | logger.step("corr", corr)
88 |
89 | optimizer.zero_grad()
90 | loss.backward()
91 | optimizer.step()
92 |
93 | if i % 20 == 0:
94 | model.eval()
95 | val_loss = loss_func(model, x_val, y_val)
96 | model.train()
97 | print(f"val_loss = {val_loss}")
98 |
99 | if i == 2000:
100 | break
101 |
--------------------------------------------------------------------------------
/old/train_unet.py:
--------------------------------------------------------------------------------
1 |
2 | import numpy as np
3 | import random, sys, os, json, glob
4 | import tqdm, itertools, shutil
5 |
6 | import matplotlib as mpl
7 |
8 | mpl.use("Agg")
9 | import matplotlib.pyplot as plt
10 |
11 | import torch
12 |
13 | torch.backends.cudnn.benchmark = True
14 | import torch.nn as nn
15 | import torch.nn.functional as F
16 | import torch.optim as optim
17 | from torch.autograd import Variable
18 |
19 | from utils import *
20 | import transforms
21 | from models import UNet
22 | from logger import Logger
23 |
24 | from sklearn.metrics import roc_auc_score
25 | from scipy.stats import pearsonr
26 | import IPython
27 |
28 | DATA_PATH = "data/encode_120"
29 | logger = Logger("train_dsc", ("loss", "corr"), print_every=5, plot_every=20)
30 |
31 |
32 | def loss_func(model, x, y):
33 | cleaned = model.forward(x)
34 | corr, p = pearsonr(
35 | cleaned.data.cpu().numpy().flatten(), y.data.cpu().numpy().flatten()
36 | )
37 | return (cleaned - y).pow(2).sum(), corr
38 |
39 |
40 | def data_gen(files, batch_size=64):
41 | while True:
42 | enc_files = random.sample(files, batch_size)
43 | orig_files = [f.replace("encoded", "original") for f in enc_files]
44 | encoded_ims = [im.load(image) for image in enc_files]
45 | original_ims = [im.load(image) for image in orig_files]
46 | encoded, original = im.stack(encoded_ims), im.stack(original_ims)
47 |
48 | yield original, (encoded - original)
49 |
50 |
51 | def viz_preds(model, x, y):
52 | preds = model(x)
53 | for i, (pred, truth, enc) in enumerate(zip(preds, y, x)):
54 | im.save(im.numpy(enc + truth), f"{OUTPUT_DIR}{i}_encoded.jpg")
55 | im.save(3 * np.abs(im.numpy(pred)), f"{OUTPUT_DIR}{i}_pred.jpg")
56 | im.save(3 * np.abs(im.numpy(truth)), f"{OUTPUT_DIR}{i}_truth.jpg")
57 |
58 |
59 | if __name__ == "__main__":
60 |
61 | model = nn.DataParallel(UNet())
62 | model.train()
63 |
64 | optimizer = torch.optim.Adam(model.parameters(), lr=3e-3)
65 |
66 | # optimizer.load_state_dict('output/unet_opt.pth')
67 | model.module.load("output/train_unet.pth")
68 |
69 | logger.add_hook(
70 | lambda: [
71 | print(f"Saving model/opt to {OUTPUT_DIR}train_unet.pth"),
72 | model.module.save(OUTPUT_DIR + "train_unet.pth"),
73 | torch.save(optimizer.state_dict(), OUTPUT_DIR + "unet_opt.pth"),
74 | ],
75 | freq=100,
76 | )
77 |
78 | files = glob.glob(f"{DATA_PATH}/*encoded*.jpg")
79 | train_files, val_files = files[:-142], files[-142:]
80 | x_val, y_val = next(data_gen(val_files, 142))
81 |
82 | for i, (x, y) in enumerate(data_gen(train_files, 142)):
83 | loss, corr = loss_func(model, x, y)
84 |
85 | logger.step("loss", min(5000, loss))
86 | logger.step("corr", corr)
87 |
88 | optimizer.zero_grad()
89 | loss.backward()
90 | optimizer.step()
91 |
92 | if i % 50 == 0:
93 | model.eval()
94 | val_loss = loss_func(model, x_val, y_val)
95 | viz_preds(model, x_val[:8], y_val[:8])
96 | model.train()
97 | print(f"val_loss = {val_loss}")
98 |
99 | if i == 2000:
100 | break
101 |
--------------------------------------------------------------------------------
/old/losses.py:
--------------------------------------------------------------------------------
1 | from __future__ import print_function
2 |
3 | import numpy as np
4 | import random, sys, os, json
5 |
6 | import matplotlib as mpl
7 |
8 | mpl.use("Agg")
9 | import matplotlib.pyplot as plt
10 |
11 | import torch
12 | import torch.nn as nn
13 | import torch.nn.functional as F
14 | import torch.optim as optim
15 | from torch.autograd import Variable
16 |
17 | from torchvision import models
18 | from utils import *
19 |
20 | from skimage import filters
21 | from skimage.morphology import binary_dilation
22 |
23 | import IPython
24 |
25 | import transforms
26 |
27 |
28 | def getFeatures(model, x):
29 | x = torch.cat(
30 | [
31 | ((x[0] - 0.485) / (0.229)).unsqueeze(0),
32 | ((x[1] - 0.456) / (0.224)).unsqueeze(0),
33 | ((x[2] - 0.406) / (0.225)).unsqueeze(0),
34 | ],
35 | dim=0,
36 | )
37 | x = transforms.identity(x).unsqueeze(0)
38 |
39 | features = []
40 | prev_feat = x
41 |
42 | for i, module in enumerate(model.features.features._modules.values()):
43 | next_feat = module(prev_feat)
44 | features.append(next_feat)
45 | prev_feat = next_feat
46 |
47 | return features
48 |
49 |
50 | def gram_matrix(features, normalize=True):
51 | N, C, H, W = features.shape
52 | featuresReshaped = features.reshape((N, C, H * W))
53 | featuresTranspose = featuresReshaped.permute(0, 2, 1)
54 | ans = torch.matmul(featuresReshaped, featuresTranspose)
55 | if normalize:
56 | ans /= H * W * C
57 | return ans
58 |
59 |
60 | # features_list is a list of layers of model to calculate content at
61 | # weights_list is a list of corresponding weights for features_list
62 | def content_loss(model, features_list, weights_list, changed_image, original_image):
63 |
64 | original_features = model.getFeatures(original_image)
65 | changed_features = model.getFeatures(changed_image)
66 |
67 | loss = 0
68 |
69 | for i, layer_number in enumerate(features_list):
70 | activation_changed = changed_features[layer_number]
71 | activation_original = original_features[layer_number]
72 |
73 | N, C_1, H_1, W_1 = activation_changed.shape
74 | F_ij = activation_changed.reshape((C_1, H_1 * W_1))
75 | P_ij = activation_original.reshape((C_1, H_1 * W_1))
76 | loss += weights_list[i] * (((F_ij - P_ij).norm(2)) ** 2)
77 |
78 | return loss
79 |
80 |
81 | def gram_matrix(features, normalize=True):
82 | N, C, H, W = features.shape
83 | featuresReshaped = features.reshape((N, C, H * W))
84 | featuresTranspose = featuresReshaped.permute(0, 2, 1)
85 | ans = torch.matmul(featuresReshaped, featuresTranspose)
86 | if normalize:
87 | ans /= H * W * C
88 | return ans
89 |
90 |
91 | # features_list is a list of layers of model to calculate style at
92 | # weights_list is a list of corresponding weights for features_list
93 | def style_loss(model, features_list, weights_list, changed_image, original_image):
94 |
95 | original_features = model.getFeatures(original_image)
96 | changed_features = model.getFeatures(changed_image)
97 |
98 | loss = 0
99 |
100 | for i, layer_number in enumerate(features_list):
101 | activation_changed = changed_features[layer_number]
102 | activation_original = original_features[layer_number]
103 | changed_gram = gram_matrix(activation_changed)
104 | original_gram = gram_matrix(activation_original)
105 | loss += weights_list[i] * (((changed_gram - original_gram).norm(2)) ** 2)
106 |
107 | return loss
108 |
--------------------------------------------------------------------------------
/train_amnesia.py:
--------------------------------------------------------------------------------
1 |
2 | import numpy as np
3 | import random, sys, os, json, glob
4 | import tqdm, itertools, shutil
5 |
6 | import matplotlib as mpl
7 |
8 | mpl.use("Agg")
9 | import matplotlib.pyplot as plt
10 |
11 | import torch
12 |
13 | torch.backends.cudnn.benchmark = True
14 | import torch.nn as nn
15 | import torch.nn.functional as F
16 | import torch.optim as optim
17 | from torch.autograd import Variable
18 |
19 | from utils import *
20 | import transforms
21 | from encoding import encode_binary
22 | from models import DecodingModel, DataParallelModel
23 | from logger import Logger, VisdomLogger
24 |
25 | from skimage.morphology import binary_dilation
26 | import IPython
27 |
28 | from testing import test_transforms
29 |
30 |
31 | def loss_func(model, x, targets):
32 | scores = model.forward(x)
33 | predictions = scores.mean(dim=1)
34 | score_targets = binary.target(targets).unsqueeze(1).expand_as(scores)
35 |
36 | return (F.binary_cross_entropy(scores, score_targets), predictions.cpu().data.numpy().round(2))
37 |
38 |
39 | def init_data(output_path, n=None):
40 |
41 | shutil.rmtree(output_path)
42 | os.makedirs(output_path)
43 |
44 | image_files = TRAIN_FILES
45 | if n is not None:
46 | image_files = image_files[0:n]
47 |
48 | for k, files in tqdm.tqdm(list(enumerate(batch(image_files, batch_size=BATCH_SIZE))), ncols=50):
49 |
50 | images = im.stack([im.load(img_file) for img_file in files]).detach()
51 | perturbation = nn.Parameter(0.03 * torch.randn(images.size()).to(DEVICE) + 0.0)
52 | targets = [binary.random(n=TARGET_SIZE) for i in range(len(images))]
53 | torch.save((perturbation.data, images.data, targets), f"{output_path}/{k}.pth")
54 |
55 |
56 | if __name__ == "__main__":
57 |
58 | model = DataParallelModel(DecodingModel(n=DIST_SIZE, distribution=transforms.training))
59 | params = itertools.chain(model.module.classifier.parameters(), model.module.features[-1].parameters())
60 | optimizer = torch.optim.Adam(params, lr=2.5e-3)
61 | init_data("data/amnesia")
62 |
63 | logger = VisdomLogger("train", server="35.230.67.129", port=8000, env=JOB)
64 | logger.add_hook(lambda x: logger.step(), feature="epoch", freq=20)
65 | logger.add_hook(lambda data: logger.plot(data, "train_loss"), feature="loss", freq=50)
66 | logger.add_hook(lambda data: logger.plot(data, "train_bits"), feature="bits", freq=50)
67 | logger.add_hook(lambda x: model.save("output/train_test.pth", verbose=True), feature="epoch", freq=100)
68 | model.save("output/train_test.pth", verbose=True)
69 |
70 | files = glob.glob(f"data/amnesia/*.pth")
71 | for i, save_file in enumerate(random.choice(files) for i in range(0, 2701)):
72 |
73 | perturbation, images, targets = torch.load(save_file)
74 | perturbation = perturbation.requires_grad_()
75 |
76 | perturbation.requires_grad = True
77 | encoded_ims, perturbation = encode_binary(
78 | images, targets, model, max_iter=1, perturbation=perturbation, use_weighting=True
79 | )
80 |
81 | loss, predictions = loss_func(model, encoded_ims, targets)
82 | error = np.mean([binary.distance(x, y) for x, y in zip(predictions, targets)])
83 |
84 | logger.update("epoch", i)
85 | logger.update("loss", loss)
86 | logger.update("bits", error)
87 |
88 | loss.backward()
89 | optimizer.step()
90 | optimizer.zero_grad()
91 |
92 | torch.save((perturbation.data, images.data, targets), save_file)
93 |
94 | if i != 0 and i % 300 == 0:
95 |
96 | model.save("output/train_test.pth")
97 | model2 = DataParallelModel(
98 | DecodingModel.load(distribution=transforms.training, n=DIST_SIZE, weights_file="output/train_test.pth")
99 | )
100 | # test_transforms(model, random.sample(TRAIN_FILES, 16), name=f'iter{i}_train')
101 | test_transforms(model2, VAL_FILES, name=f"iter{i}_test", max_iter=300)
102 |
--------------------------------------------------------------------------------
/old/modules.py:
--------------------------------------------------------------------------------
1 |
2 | from __future__ import print_function
3 |
4 | import numpy as np
5 | import random, sys, os, json
6 |
7 | import torch
8 | import torch.nn as nn
9 | import torch.nn.functional as F
10 | import torch.optim as optim
11 | from torch.autograd import Variable
12 |
13 | from torchvision import models
14 | from utils import *
15 | import transforms
16 |
17 | import IPython
18 |
19 |
20 | class UNet_down_block(nn.Module):
21 | def __init__(self, input_channel, output_channel, down_size=True):
22 | super(UNet_down_block, self).__init__()
23 | self.conv1 = nn.Conv2d(input_channel, output_channel, 3, padding=1)
24 | self.bn1 = nn.BatchNorm2d(output_channel)
25 | self.conv2 = nn.Conv2d(output_channel, output_channel, 3, padding=1)
26 | self.bn2 = nn.BatchNorm2d(output_channel)
27 | self.max_pool = nn.MaxPool2d(2, 2)
28 | self.relu = nn.ReLU()
29 | self.down_size = down_size
30 |
31 | def forward(self, x):
32 |
33 | x = self.relu(self.bn1(self.conv1(x)))
34 | x = self.relu(self.bn2(self.conv2(x)))
35 | if self.down_size:
36 | x = self.max_pool(x)
37 | return x
38 |
39 |
40 | class UNet_up_block(nn.Module):
41 | def __init__(self, prev_channel, input_channel, output_channel, up_sample=True):
42 | super(UNet_up_block, self).__init__()
43 | self.up_sampling = nn.Upsample(scale_factor=2, mode="bilinear")
44 | self.conv1 = nn.Conv2d(
45 | prev_channel + input_channel, output_channel, 3, padding=1
46 | )
47 | self.bn1 = nn.BatchNorm2d(output_channel)
48 | self.conv2 = nn.Conv2d(output_channel, output_channel, 3, padding=1)
49 | self.bn2 = nn.BatchNorm2d(output_channel)
50 | self.relu = torch.nn.ReLU()
51 | self.up_sample = up_sample
52 |
53 | def forward(self, prev_feature_map, x):
54 | if self.up_sample:
55 | x = self.up_sampling(x)
56 | x = torch.cat((x, prev_feature_map), dim=1)
57 | x = self.relu(self.bn1(self.conv1(x)))
58 | x = self.relu(self.bn2(self.conv2(x)))
59 | return x
60 |
61 |
62 | class UNet(nn.Module):
63 | def __init__(self):
64 | super(UNet, self).__init__()
65 |
66 | self.down_block1 = UNet_down_block(3, 16, False)
67 | self.down_block2 = UNet_down_block(16, 32, True)
68 | self.down_block3 = UNet_down_block(32, 64, True)
69 | self.down_block4 = UNet_down_block(64, 128, True)
70 | self.down_block5 = UNet_down_block(128, 256, True)
71 | # self.down_block6 = UNet_down_block(256, 512, True)
72 |
73 | self.mid_conv1 = nn.Conv2d(256, 256, 3, padding=1)
74 | self.bn1 = nn.BatchNorm2d(256)
75 | # self.mid_conv2 = nn.Conv2d(512, 512, 3, padding=1)
76 | # self.bn2 = nn.BatchNorm2d(512)
77 | # self.mid_conv3 = torch.nn.Conv2d(512, 512, 3, padding=1)
78 | # self.bn3 = torch.nn.BatchNorm2d(512)
79 |
80 | # self.up_block1 = UNet_up_block(256, 512, 256)
81 | self.up_block2 = UNet_up_block(128, 256, 128)
82 | self.up_block3 = UNet_up_block(64, 128, 64)
83 | self.up_block4 = UNet_up_block(32, 64, 32)
84 | self.up_block5 = UNet_up_block(16, 32, 16)
85 |
86 | self.last_conv1 = nn.Conv2d(16, 16, 3, padding=1)
87 | self.last_bn = nn.BatchNorm2d(16)
88 | self.last_conv2 = nn.Conv2d(16, 3, 1, padding=0)
89 | self.relu = nn.ReLU()
90 | self.to(DEVICE)
91 |
92 | def forward(self, x):
93 | self.x1 = self.down_block1(x)
94 | self.x2 = self.down_block2(self.x1)
95 | self.x3 = self.down_block3(self.x2)
96 | self.x4 = self.down_block4(self.x3)
97 | self.x5 = self.down_block5(self.x4)
98 | # self.x6 = self.down_block6(self.x5)
99 |
100 | self.x5 = self.relu(self.bn1(self.mid_conv1(self.x5)))
101 | # self.x6 = self.relu(self.bn2(self.mid_conv2(self.x6)))
102 | # self.x6 = self.relu(self.bn3(self.mid_conv3(self.x6)))
103 |
104 | # x = self.up_block1(self.x5, self.x6)
105 | x = self.up_block2(self.x4, self.x5)
106 | x = self.up_block3(self.x3, x)
107 | x = self.up_block4(self.x2, x)
108 | x = self.up_block5(self.x1, x)
109 | x = self.relu(self.last_bn(self.last_conv1(x)))
110 | x = self.last_conv2(x)
111 | return x
112 |
113 | def load(self, file_path):
114 | self.load_state_dict(torch.load(file_path))
115 |
116 | def save(self, file_path):
117 | torch.save(self.state_dict(), file_path)
118 |
--------------------------------------------------------------------------------
/encoding.py:
--------------------------------------------------------------------------------
1 |
2 | import random, sys, os, json, glob, argparse
3 |
4 | import numpy as np
5 | import matplotlib as mpl
6 |
7 | mpl.use("Agg")
8 | import matplotlib.pyplot as plt
9 | from fire import Fire
10 |
11 | import torch
12 | import torch.nn as nn
13 | import torch.nn.functional as F
14 | import torch.optim as optim
15 | from torch.autograd import Variable
16 |
17 | from models import DecodingModel, DataParallelModel
18 | from torchvision import models
19 | from logger import Logger, VisdomLogger
20 | from utils import *
21 |
22 | import IPython
23 |
24 | import transforms
25 |
26 |
27 | # LOGGING
28 | logger = VisdomLogger("encoding", server="35.230.67.129", port=8000, env=JOB)
29 | logger.add_hook(lambda x: logger.step(), feature="epoch", freq=20)
30 | logger.add_hook(lambda x: logger.plot(x, "Encoding Loss", opts=dict(ymin=0)), feature="loss", freq=50)
31 |
32 |
33 | """
34 | Computes the changed images, given a a specified perturbation, standard deviation weighting,
35 | and epsilon.
36 | """
37 |
38 |
39 | def compute_changed_images(images, perturbation, std_weights, epsilon=EPSILON):
40 |
41 | perturbation_w2 = perturbation * std_weights
42 | perturbation_zc = (
43 | perturbation_w2
44 | / perturbation_w2.view(perturbation_w2.shape[0], -1)
45 | .norm(2, dim=1, keepdim=True)
46 | .unsqueeze(2)
47 | .unsqueeze(2)
48 | .expand_as(perturbation_w2)
49 | * epsilon
50 | * (perturbation_w2[0].nelement() ** 0.5)
51 | )
52 |
53 | changed_images = (images + perturbation_zc).clamp(min=0.0, max=1.0)
54 | return changed_images
55 |
56 |
57 | """
58 | Computes the cross entropy loss of a set of encoded images, given the model and targets.
59 | """
60 |
61 |
62 | def loss_func(model, x, targets):
63 | scores = model.forward(x)
64 | predictions = scores.mean(dim=1)
65 | score_targets = binary.target(targets).unsqueeze(1).expand_as(scores)
66 |
67 | return (F.binary_cross_entropy(scores, score_targets), predictions.cpu().data.numpy().round(2))
68 |
69 |
70 | """
71 | Encodes a set of images with the specified binary targets, for a given number of iterations.
72 | """
73 |
74 |
75 | def encode_binary(
76 | images, targets, model=DecodingModel(), n=None, max_iter=500, verbose=False, perturbation=None, use_weighting=False
77 | ):
78 |
79 | if n is not None:
80 | if verbose:
81 | print(f"Changing distribution size: {model.n} -> {n}")
82 | n, model.n = (model.n, n)
83 |
84 | returnPerturbation = True
85 | if perturbation is None:
86 | perturbation = nn.Parameter(0.03 * torch.randn(images.size()).to(DEVICE) + 0.0)
87 | returnPerturbation = False
88 |
89 | changed_images = images.detach()
90 | optimizer = torch.optim.Adam([perturbation], lr=ENCODING_LR)
91 | std_weights = get_std_weight(images, alpha=PERT_ALPHA) if use_weighting else 1
92 |
93 | for i in range(0, max_iter):
94 |
95 | changed_images = compute_changed_images(images, perturbation, std_weights)
96 | loss, predictions = loss_func(model, changed_images, targets)
97 |
98 | loss.backward()
99 | optimizer.step()
100 | optimizer.zero_grad()
101 |
102 | error = np.mean([binary.distance(x, y) for x, y in zip(predictions, targets)])
103 |
104 | if verbose:
105 | logger.update("epoch", i)
106 | logger.update("loss", loss)
107 | logger.update("bits", error)
108 |
109 | changed_images = compute_changed_images(images, perturbation, std_weights)
110 |
111 | if n is not None:
112 | if verbose:
113 | print(f"Fixing distribution size: {model.n} -> {n}")
114 | n, model.n = (model.n, n)
115 |
116 | if returnPerturbation:
117 | return changed_images.detach(), perturbation.detach()
118 |
119 | return changed_images.detach()
120 |
121 |
122 | """
123 | Command-line interface for encoding a single image.
124 | """
125 |
126 |
127 | def encode(
128 | image,
129 | out,
130 | target=binary.str(binary.random(TARGET_SIZE)),
131 | n=96,
132 | model=None,
133 | max_iter=500,
134 | use_weighting=True,
135 | perturbation_out=None,
136 | ):
137 |
138 | if not isinstance(model, DecodingModel):
139 | model = DataParallelModel(DecodingModel.load(distribution=transforms.encoding, n=n, weights_file=model))
140 | image = im.torch(im.load(image)).unsqueeze(0)
141 | print("Target: ", target)
142 | target = binary.parse(str(target))
143 | encoded = encode_binary(image, [target], model, n=n, verbose=True, max_iter=max_iter, use_weighting=use_weighting)
144 | im.save(im.numpy(encoded.squeeze()), file=out)
145 | if perturbation_out != None:
146 | im.save(im.numpy((image - encoded).squeeze()), file=perturbation_out)
147 |
148 |
149 | if __name__ == "__main__":
150 | Fire(encode)
151 |
--------------------------------------------------------------------------------
/web/client/src/registerServiceWorker.js:
--------------------------------------------------------------------------------
1 | // In production, we register a service worker to serve assets from local cache.
2 |
3 | // This lets the app load faster on subsequent visits in production, and gives
4 | // it offline capabilities. However, it also means that developers (and users)
5 | // will only see deployed updates on the "N+1" visit to a page, since previously
6 | // cached resources are updated in the background.
7 |
8 | // To learn more about the benefits of this model, read https://goo.gl/KwvDNy.
9 | // This link also includes instructions on opting out of this behavior.
10 |
11 | const isLocalhost = Boolean(
12 | window.location.hostname === 'localhost' ||
13 | // [::1] is the IPv6 localhost address.
14 | window.location.hostname === '[::1]' ||
15 | // 127.0.0.1/8 is considered localhost for IPv4.
16 | window.location.hostname.match(
17 | /^127(?:\.(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)){3}$/
18 | )
19 | );
20 |
21 | export default function register() {
22 | if (process.env.NODE_ENV === 'production' && 'serviceWorker' in navigator) {
23 | // The URL constructor is available in all browsers that support SW.
24 | const publicUrl = new URL(process.env.PUBLIC_URL, window.location);
25 | if (publicUrl.origin !== window.location.origin) {
26 | // Our service worker won't work if PUBLIC_URL is on a different origin
27 | // from what our page is served on. This might happen if a CDN is used to
28 | // serve assets; see https://github.com/facebookincubator/create-react-app/issues/2374
29 | return;
30 | }
31 |
32 | window.addEventListener('load', () => {
33 | const swUrl = `${process.env.PUBLIC_URL}/service-worker.js`;
34 |
35 | if (isLocalhost) {
36 | // This is running on localhost. Lets check if a service worker still exists or not.
37 | checkValidServiceWorker(swUrl);
38 |
39 | // Add some additional logging to localhost, pointing developers to the
40 | // service worker/PWA documentation.
41 | navigator.serviceWorker.ready.then(() => {
42 | console.log(
43 | 'This web app is being served cache-first by a service ' +
44 | 'worker. To learn more, visit https://goo.gl/SC7cgQ'
45 | );
46 | });
47 | } else {
48 | // Is not local host. Just register service worker
49 | registerValidSW(swUrl);
50 | }
51 | });
52 | }
53 | }
54 |
55 | function registerValidSW(swUrl) {
56 | navigator.serviceWorker
57 | .register(swUrl)
58 | .then(registration => {
59 | registration.onupdatefound = () => {
60 | const installingWorker = registration.installing;
61 | installingWorker.onstatechange = () => {
62 | if (installingWorker.state === 'installed') {
63 | if (navigator.serviceWorker.controller) {
64 | // At this point, the old content will have been purged and
65 | // the fresh content will have been added to the cache.
66 | // It's the perfect time to display a "New content is
67 | // available; please refresh." message in your web app.
68 | console.log('New content is available; please refresh.');
69 | } else {
70 | // At this point, everything has been precached.
71 | // It's the perfect time to display a
72 | // "Content is cached for offline use." message.
73 | console.log('Content is cached for offline use.');
74 | }
75 | }
76 | };
77 | };
78 | })
79 | .catch(error => {
80 | console.error('Error during service worker registration:', error);
81 | });
82 | }
83 |
84 | function checkValidServiceWorker(swUrl) {
85 | // Check if the service worker can be found. If it can't reload the page.
86 | fetch(swUrl)
87 | .then(response => {
88 | // Ensure service worker exists, and that we really are getting a JS file.
89 | if (
90 | response.status === 404 ||
91 | response.headers.get('content-type').indexOf('javascript') === -1
92 | ) {
93 | // No service worker found. Probably a different app. Reload the page.
94 | navigator.serviceWorker.ready.then(registration => {
95 | registration.unregister().then(() => {
96 | window.location.reload();
97 | });
98 | });
99 | } else {
100 | // Service worker found. Proceed as normal.
101 | registerValidSW(swUrl);
102 | }
103 | })
104 | .catch(() => {
105 | console.log(
106 | 'No internet connection found. App is running in offline mode.'
107 | );
108 | });
109 | }
110 |
111 | export function unregister() {
112 | if ('serviceWorker' in navigator) {
113 | navigator.serviceWorker.ready.then(registration => {
114 | registration.unregister();
115 | });
116 | }
117 | }
118 |
--------------------------------------------------------------------------------
/logger.py:
--------------------------------------------------------------------------------
1 |
2 | import numpy as np
3 | import matplotlib as mpl
4 |
5 | mpl.use("Agg")
6 | import matplotlib.pyplot as plt
7 | import random, sys, os, json, math
8 |
9 | import torch
10 | from torchvision import datasets, transforms
11 | import visdom
12 |
13 | from utils import *
14 | import IPython
15 |
16 |
17 | class BaseLogger(object):
18 | def __init__(self, name, verbose=True):
19 |
20 | self.name = name
21 | self.data = {}
22 | self.running_data = {}
23 | self.reset_running = {}
24 | self.verbose = verbose
25 | self.hooks = []
26 |
27 | def add_hook(self, hook, feature="epoch", freq=40):
28 | self.hooks.append((hook, feature, freq))
29 |
30 | def update(self, feature, x):
31 | if isinstance(x, torch.Tensor):
32 | x = x.data.cpu().numpy().mean()
33 |
34 | self.data[feature] = self.data.get(feature, [])
35 | self.data[feature].append(x)
36 | if feature not in self.running_data or self.reset_running.pop(feature, False):
37 | self.running_data[feature] = []
38 | self.running_data[feature].append(x)
39 |
40 | for hook, hook_feature, freq in self.hooks:
41 | if feature == hook_feature and len(self.data[feature]) % freq == 0:
42 | hook(self.data[feature])
43 |
44 | def step(self):
45 | self.text(f"({self.name}) ", end="")
46 | for feature in self.running_data.keys():
47 | if len(self.running_data[feature]) == 0:
48 | continue
49 | val = np.mean(self.running_data[feature])
50 | if float(val).is_integer():
51 | self.text(f"{feature}: {int(val)}", end=", ")
52 | else:
53 | self.text(f"{feature}: {val:0.4f}", end=", ")
54 | self.reset_running[feature] = True
55 | self.text(f" ... {elapsed():0.2f} sec")
56 |
57 | def text(self, text, end="\n"):
58 | raise NotImplementedError()
59 |
60 | def plot(self, data, plot_name, opts={}):
61 | raise NotImplementedError()
62 |
63 | def images(self, data, image_name):
64 | raise NotImplementedError()
65 |
66 |
67 | class Logger(BaseLogger):
68 | def __init__(self, *args, **kwargs):
69 | self.results = kwargs.pop("results", "output")
70 | super().__init__(*args, **kwargs)
71 |
72 | def text(self, text, end="\n"):
73 | print(text, end=end, flush=True)
74 |
75 | def plot(self, data, plot_name, opts={}):
76 | np.savez_compressed(f"{self.results}/{plot_name}.npz", data)
77 | plt.plot(data)
78 | plt.savefig(f"{self.results}/{plot_name}.jpg")
79 | plt.clf()
80 |
81 |
82 | class VisdomLogger(BaseLogger):
83 | def __init__(self, *args, **kwargs):
84 | self.port = kwargs.pop("port", 7000)
85 | self.server = kwargs.pop("server", "35.230.67.129")
86 | self.env = kwargs.pop("env", "main")
87 | print(f"Logging to environment {self.env}")
88 | self.visdom = visdom.Visdom(
89 | server="http://" + self.server, port=self.port, env=self.env, use_incoming_socket=False
90 | )
91 | self.visdom.delete_env(self.env)
92 | self.windows = {}
93 | super().__init__(*args, **kwargs)
94 |
95 | def text(self, text, end="\n"):
96 | print(text, end=end)
97 | window, old_text = self.windows.get("text", (None, ""))
98 | if end == "\n":
99 | end = "" 100 | display = old_text + text + end 101 | 102 | if window is not None: 103 | window = self.visdom.text(display, win=window, append=False) 104 | else: 105 | window = self.visdom.text(display) 106 | 107 | self.windows["text"] = window, display 108 | 109 | def viz(self, viz_name, method, *args, **kwargs): 110 | window = self.windows.get(viz_name, None) 111 | if window is not None: 112 | window = getattr(self.visdom, method)(*args, **kwargs, win=window) 113 | else: 114 | window = getattr(self.visdom, method)(*args, **kwargs, win=window) 115 | self.windows[viz_name] = window 116 | 117 | def plot(self, data, plot_name, opts={}): 118 | 119 | window = self.windows.get(plot_name, None) 120 | opts.update({"title": plot_name}) 121 | 122 | self.viz(plot_name, "line", np.array(data), opts=opts) 123 | 124 | def images(self, data, image_name, opts={}, resize=64): 125 | 126 | transform = transforms.Compose([transforms.ToPILImage(), transforms.Resize(resize), transforms.ToTensor()]) 127 | data = torch.stack([transform(x) for x in data.cpu()]) 128 | data = data.data.cpu().numpy() 129 | 130 | window = self.windows.get(image_name, None) 131 | 132 | opts.update({"title": image_name}) 133 | self.viz(image_name, "images", np.array(data), opts=opts) 134 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # NeuralHash: An Adversarial Steganographic Method For Robust, Imperceptible Watermarking 2 | Building the next-gen watermark with deep learning: imperceptibly encoding images with un-erasable patterns to verify content ownership. 3 | 4 | ## What it does: 5 | Given an image (like Scream), Neuralhash makes small perturbations to visually encode a unique signature of the author: 6 | 7 |
8 |
9 | Which is able to be decoded even after extreme transformations (like a cellphone photo of the encoded image):
10 |
11 |
12 | 
13 |
20 | 
21 |
24 | 
25 |
30 | 
31 |
35 | 
36 |
42 |
43 | ## Example Attacks
44 | Some examples where our approach succeessfully decodes the correct signature and examples where it fails:
45 |
46 | 
47 |
48 | ## Final Thoughts:
49 |
50 | The development of a secure watermarking scheme is an important problem that has applications in content ownership and piracy prevention. Current state-of-the-art techniques are unable to document robustness across a variety of affine transformations. We propose a method that harnesses the expressiveness of deep neural networks to covertly embed imperceptible, transformation-resilient binary signatures into images. Given a decoder network, our key insight is that adversarial example generation techniques can be used to encode images by performing projected gradient descent on the image to embed a chosen signature.
51 |
52 | By performing projective gradient descent on the decoder model with respect to a given image, we can use it to “sign” images robustly (think of a more advanced watermark). We start with the original image, then repeatedly tweak the pixel values such that the image (and all transformations, including scaling, rotation, adding noise, blurring, random cropping, and more) decodes to a specified 32-bit code. The resultant image will be almost imperceptible from the original image, yet contain an easily-decodable signature that cannot be removed even by the most dedicated of adversaries.
53 |
54 | We also propose a method to train our decoder network under the Expectation-Maximization (EM) framework to learn feature transformations that are more resilient to the threat space of attacks. Experimental results indicate that our model achieves robustness across different transformations such as scaling and rotating, with improved results over the length of EM training. Furthermore, we show an inherent trade-off between robustness and imperceptibility, which allows the user of the model flexibility in adjusting parameters to fit a particular task.
55 |
56 | Paper and more details coming soon.
57 |
--------------------------------------------------------------------------------
/web/client/src/pages/background.js:
--------------------------------------------------------------------------------
1 |
2 |
3 | var colorPicker = (function() {
4 | var colors = ["#FF6138", "#FFBE53", "#2980B9", "#282741"];
5 | var index = 0;
6 | function next() {
7 | index = index++ < colors.length - 1 ? index : 0;
8 | return colors[index];
9 | }
10 | function current() {
11 | return colors[index];
12 | }
13 | return {
14 | next: next,
15 | current: current
16 | };
17 | })();
18 |
19 | function removeAnimation(animation) {
20 | var index = animations.indexOf(animation);
21 | if (index > -1) animations.splice(index, 1);
22 | }
23 |
24 | function calcPageFillRadius(x, y) {
25 | var l = Math.max(x - 0, cW - x);
26 | var h = Math.max(y - 0, cH - y);
27 | return Math.sqrt(Math.pow(l, 2) + Math.pow(h, 2));
28 | }
29 |
30 | function addClickListeners() {
31 | document.addEventListener("touchstart", handleEvent);
32 | document.addEventListener("mousedown", handleEvent);
33 | }
34 |
35 | function handleEvent(e) {
36 | if (e.touches) {
37 | e.preventDefault();
38 | e = e.touches[0];
39 | }
40 | var currentColor = colorPicker.current();
41 | var nextColor = colorPicker.next();
42 | var targetR = calcPageFillRadius(e.pageX, e.pageY);
43 | var rippleSize = Math.min(200, cW * 0.4);
44 | var minCoverDuration = 750;
45 |
46 | var pageFill = new Circle({
47 | x: e.pageX,
48 | y: e.pageY,
49 | r: 0,
50 | fill: nextColor
51 | });
52 | var fillAnimation = anime({
53 | targets: pageFill,
54 | r: targetR,
55 | duration: Math.max(targetR / 2, minCoverDuration),
56 | easing: "easeOutQuart",
57 | complete: function() {
58 | bgColor = pageFill.fill;
59 | removeAnimation(fillAnimation);
60 | }
61 | });
62 |
63 | var ripple = new Circle({
64 | x: e.pageX,
65 | y: e.pageY,
66 | r: 0,
67 | fill: currentColor,
68 | stroke: {
69 | width: 3,
70 | color: currentColor
71 | },
72 | opacity: 1
73 | });
74 | var rippleAnimation = anime({
75 | targets: ripple,
76 | r: rippleSize,
77 | opacity: 0,
78 | easing: "easeOutExpo",
79 | duration: 900,
80 | complete: removeAnimation
81 | });
82 |
83 | var particles = [];
84 | for (var i = 0; i < 32; i++) {
85 | var particle = new Circle({
86 | x: e.pageX,
87 | y: e.pageY,
88 | fill: currentColor,
89 | r: anime.random(24, 48)
90 | });
91 | particles.push(particle);
92 | }
93 | var particlesAnimation = anime({
94 | targets: particles,
95 | x: function(particle) {
96 | return particle.x + anime.random(rippleSize, -rippleSize);
97 | },
98 | y: function(particle) {
99 | return particle.y + anime.random(rippleSize * 1.15, -rippleSize * 1.15);
100 | },
101 | r: 0,
102 | easing: "easeOutExpo",
103 | duration: anime.random(1000, 1300),
104 | complete: removeAnimation
105 | });
106 | animations.push(fillAnimation, rippleAnimation, particlesAnimation);
107 | }
108 |
109 | function extend(a, b) {
110 | for (var key in b) {
111 | if (b.hasOwnProperty(key)) {
112 | a[key] = b[key];
113 | }
114 | }
115 | return a;
116 | }
117 |
118 | var Circle = function(opts) {
119 | extend(this, opts);
120 | };
121 |
122 | Circle.prototype.draw = function() {
123 | ctx.globalAlpha = this.opacity || 1;
124 | ctx.beginPath();
125 | ctx.arc(this.x, this.y, this.r, 0, 2 * Math.PI, false);
126 | if (this.stroke) {
127 | ctx.strokeStyle = this.stroke.color;
128 | ctx.lineWidth = this.stroke.width;
129 | ctx.stroke();
130 | }
131 | if (this.fill) {
132 | ctx.fillStyle = this.fill;
133 | ctx.fill();
134 | }
135 | ctx.closePath();
136 | ctx.globalAlpha = 1;
137 | };
138 |
139 | var animate = anime({
140 | duration: Infinity,
141 | update: function() {
142 | ctx.fillStyle = bgColor;
143 | ctx.fillRect(0, 0, cW, cH);
144 | animations.forEach(function(anim) {
145 | anim.animatables.forEach(function(animatable) {
146 | animatable.target.draw();
147 | });
148 | });
149 | }
150 | });
151 |
152 | var resizeCanvas = function() {
153 | cW = window.innerWidth;
154 | cH = window.innerHeight;
155 | c.width = cW * devicePixelRatio;
156 | c.height = cH * devicePixelRatio;
157 | ctx.scale(devicePixelRatio, devicePixelRatio);
158 | };
159 |
160 | (function init() {
161 | resizeCanvas();
162 | if (window.CP) {
163 | // CodePen's loop detection was causin' problems
164 | // and I have no idea why, so...
165 | window.CP.PenTimer.MAX_TIME_IN_LOOP_WO_EXIT = 6000;
166 | }
167 | window.addEventListener("resize", resizeCanvas);
168 | addClickListeners();
169 | if (!!window.location.pathname.match(/fullcpgrid/)) {
170 | startFauxClicking();
171 | }
172 | handleInactiveUser();
173 | })();
174 |
175 | function handleInactiveUser() {
176 | var inactive = setTimeout(function() {
177 | fauxClick(cW / 2, cH / 2);
178 | }, 2000);
179 |
180 | function clearInactiveTimeout() {
181 | clearTimeout(inactive);
182 | document.removeEventListener("mousedown", clearInactiveTimeout);
183 | document.removeEventListener("touchstart", clearInactiveTimeout);
184 | }
185 |
186 | document.addEventListener("mousedown", clearInactiveTimeout);
187 | document.addEventListener("touchstart", clearInactiveTimeout);
188 | }
189 |
190 | function startFauxClicking() {
191 | setTimeout(function() {
192 | fauxClick(
193 | anime.random(cW * 0.2, cW * 0.8),
194 | anime.random(cH * 0.2, cH * 0.8)
195 | );
196 | startFauxClicking();
197 | }, anime.random(200, 900));
198 | }
199 |
200 | function fauxClick(x, y) {
201 | var fauxClick = new Event("mousedown");
202 | fauxClick.pageX = x;
203 | fauxClick.pageY = y;
204 | document.dispatchEvent(fauxClick);
205 | }
206 |
--------------------------------------------------------------------------------
/web/client/src/components/ImageTrace/ImageTrace.js:
--------------------------------------------------------------------------------
1 | import React from "react";
2 | import "./ImageTrace.css";
3 |
4 | import Image from "image-js";
5 | import { toPath, toPoints } from "svg-points";
6 | import * as simplify from "simplify-js";
7 | import * as ImageTracer from "imagetracerjs";
8 | import HtmlToReact, { Parser } from "html-to-react";
9 | import { TweenLite, morphSVG, TimelineLite, SlowMo, CustomEase } from "gsap";
10 |
11 | export default class ImageTrace extends React.Component {
12 | state = {
13 | path:
195 |
204 |
205 | );
206 | }
207 | }
208 |
--------------------------------------------------------------------------------
/utils.py:
--------------------------------------------------------------------------------
1 | # utils.py
2 |
3 | import numpy as np
4 | import random, sys, os, time, glob, math
5 |
6 | import matplotlib as mpl
7 | mpl.use("Agg")
8 | import matplotlib.pyplot as plt
9 |
10 | from skimage import io, color
11 |
12 | import torch
13 | import torch.nn as nn
14 | import torch.nn.functional as F
15 | import torch.optim as optim
16 | from torch.autograd import Variable
17 | import random
18 | import IPython
19 |
20 | # CRITICAL HYPER PARAMS
21 | EPSILON = 9e-3
22 | BATCH_SIZE = 64
23 | DIST_SIZE = 48
24 | ENCODING_DIST_SIZE = 96
25 | TARGET_SIZE = 32
26 | VAL_SIZE = 16
27 | ENCODING_LR = 1e-1
28 | PERT_ALPHA = 0.5
29 | MODEL_TYPE = "DecodingGramNet"
30 |
31 | USE_CUDA = torch.cuda.is_available()
32 | DEVICE = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
33 | IMAGE_MAX = 255.0
34 | OUTPUT_DIR = "output/"
35 | DATA_FILES = sorted(glob.glob("data/colornet/*.jpg"))
36 | JOB = open("jobs/jobinfo.txt").read().strip()
37 | TRAIN_FILES, VAL_FILES = DATA_FILES[:-VAL_SIZE], DATA_FILES[-VAL_SIZE:]
38 | dtype = torch.cuda.FloatTensor if USE_CUDA else torch.FloatTensor
39 |
40 |
41 | def corrcoef(x):
42 | mean_x = torch.mean(x, 1).unsqueeze(1)
43 | xm = x.sub(mean_x.expand_as(x))
44 | c = xm.mm(xm.t())
45 | c = c / (x.size(1) - 1)
46 |
47 | # normalize covariance matrix
48 | d = torch.diag(c)
49 | stddev = torch.pow(d, 0.5)
50 | c = c.div(stddev.expand_as(c))
51 | c = c.div(stddev.expand_as(c).t())
52 |
53 | # clamp between -1 and 1
54 | # probably not necessary but numpy does it
55 | c = torch.clamp(c, -1.0, 1.0)
56 |
57 | return c
58 |
59 |
60 | def get_std_weight(images, n=5, alpha=0.5):
61 | N, C, H, W = images.shape
62 | kernel = kernel = torch.ones(C, 1, n, n)
63 | with torch.no_grad():
64 | padded = F.pad(images, (n // 2, n // 2, n // 2, n // 2), mode="replicate")
65 | sums = F.conv2d(padded, kernel.to(DEVICE), groups=3, padding=0) * (1 / (n ** 2))
66 | sums_2 = F.conv2d(padded ** 2, kernel.to(DEVICE), groups=3, padding=0) * (1 / (n ** 2))
67 | stds = (sums_2 - (sums ** 2) + 1e-5) ** alpha
68 | return stds.detach()
69 |
70 |
71 | def gram(input):
72 | N, C, H, W = input.size()
73 | features = input.view(N, C, H * W) # resise F_XL into \hat F_XL
74 | G = torch.bmm(features, features.permute(0, 2, 1)) # compute the gram product
75 | return G.div(N * C * H * W)
76 |
77 |
78 | def zca(x):
79 | sigma = torch.mm(x.t(), x) / x.shape[0]
80 | U, S, _ = torch.svd(sigma)
81 | pcs = torch.mm(torch.mm(U, torch.diag(1. / torch.sqrt(S + 1e-7))), U.t())
82 |
83 | # Apply ZCA whitening
84 | whitex = torch.mm(x, pcs)
85 | return whitex
86 |
87 |
88 | def color_normalize(x):
89 | return torch.cat(
90 | [
91 | ((x[0] - 0.485) / (0.229)).unsqueeze(0),
92 | ((x[1] - 0.456) / (0.224)).unsqueeze(0),
93 | ((x[2] - 0.406) / (0.225)).unsqueeze(0),
94 | ],
95 | dim=0,
96 | )
97 |
98 |
99 | def tve_loss(x):
100 | return ((x[:, :-1, :] - x[:, 1:, :]) ** 2).sum() + ((x[:, :, :-1] - x[:, :, 1:]) ** 2).sum()
101 |
102 |
103 | def batch(datagen, batch_size=32):
104 | arr = []
105 | for data in datagen:
106 | arr.append(data)
107 | if len(arr) == batch_size:
108 | yield arr
109 | arr = []
110 | if len(arr) != 0:
111 | yield arr
112 |
113 |
114 | def batched(datagen, batch_size=32):
115 | arr = []
116 | for data in datagen:
117 | arr.append(data)
118 | if len(arr) == batch_size:
119 | yield list(zip(*arr))
120 | arr = []
121 | if len(arr) != 0:
122 | yield list(zip(*arr))
123 |
124 |
125 | def elapsed(times=[time.time()]):
126 | times.append(time.time())
127 | return times[-1] - times[-2]
128 |
129 |
130 | def create_heatmap(data, labels, filename='output/heatmap.jpg', x_label="", y_label=""):
131 | fig, ax = plt.subplots()
132 | im = ax.imshow(data)
133 |
134 | # We want to show all ticks...
135 | ax.set_xticks(np.arange(len(labels)))
136 | ax.set_yticks(np.arange(len(labels)))
137 | # ... and label them with the respective list entries
138 | ax.set_xticklabels(labels)
139 | ax.set_yticklabels(labels)
140 |
141 | # Rotate the tick labels and set their alignment.
142 | plt.setp(ax.get_xticklabels(), rotation=45, ha="right",
143 | rotation_mode="anchor")
144 |
145 | # Loop over data dimensions and create text annotations.
146 | for i in range(len(labels)):
147 | for j in range(len(labels)):
148 | text = ax.text(j, i, "{0:.2f}".format(round(data[i,j],2)),
149 | ha="center", va="center", color="w")
150 |
151 | ax.set_title("Affinity matrix")
152 | fig.tight_layout()
153 | plt.savefig(filename)
154 | plt.cla()
155 | plt.clf()
156 | plt.close()
157 |
158 | def gaussian_filter(kernel_size=5, sigma=1.0):
159 |
160 | channels = 3
161 | # Create a x, y coordinate grid of shape (kernel_size, kernel_size, 2)
162 | x_cord = torch.arange(kernel_size).to(DEVICE)
163 | x_grid = x_cord.repeat(kernel_size).view(kernel_size, kernel_size)
164 | y_grid = x_grid.t()
165 | xy_grid = torch.stack([x_grid, y_grid], dim=-1)
166 |
167 | mean = (kernel_size - 1) / 2.
168 | variance = sigma ** 2.
169 |
170 | # Calculate the 2-dimensional gaussian kernel which is
171 | # the product of two gaussian distributions for two different
172 | # variables (in this case called x and y)
173 | gaussian_kernel = (1. / (2. * math.pi * variance)) * torch.exp(
174 | -torch.sum((xy_grid - mean) ** 2., dim=-1) / (2 * variance)
175 | )
176 | # Make sure sum of values in gaussian kernel equals 1.
177 | gaussian_kernel = gaussian_kernel.to(DEVICE) / torch.sum(gaussian_kernel).to(DEVICE)
178 |
179 | # Reshape to 2d depthwise convolutional weight
180 | gaussian_kernel = gaussian_kernel.view(1, 1, kernel_size, kernel_size)
181 | gaussian_kernel = gaussian_kernel.repeat(channels, 1, 1, 1)
182 |
183 | return gaussian_kernel
184 |
185 |
186 | def motion_blur_filter(kernel_size=15):
187 | channels = 3
188 | kernel_motion_blur = torch.zeros((kernel_size, kernel_size))
189 | kernel_motion_blur[int((kernel_size - 1) / 2), :] = torch.ones(kernel_size)
190 | kernel_motion_blur = kernel_motion_blur / kernel_size
191 | kernel_motion_blur = kernel_motion_blur.view(1, 1, kernel_size, kernel_size)
192 | kernel_motion_blur = kernel_motion_blur.repeat(channels, 1, 1, 1)
193 | return kernel_motion_blur
194 |
195 |
196 | """Image manipulation methods"""
197 |
198 |
199 | class im(object):
200 | @staticmethod
201 | def load(filename):
202 |
203 | img = None
204 |
205 | try:
206 | img = io.imread(filename) / IMAGE_MAX
207 | if len(img.shape) != 3:
208 | return None
209 | img = img[:, :, 0:3]
210 | except (IndexError, OSError) as e:
211 | img = None
212 |
213 | return img
214 |
215 | @staticmethod
216 | def save(image, file="out.jpg"):
217 | io.imsave(file, (image * IMAGE_MAX).astype(np.uint8))
218 |
219 | @staticmethod
220 | def torch(image):
221 | x = torch.tensor(image).float().permute(2, 0, 1)
222 | return x.to(DEVICE)
223 |
224 | @staticmethod
225 | def numpy(image):
226 | return image.data.permute(1, 2, 0).cpu().numpy()
227 |
228 | @staticmethod
229 | def stack(images):
230 | return torch.cat([im.torch(image).unsqueeze(0) for image in images], dim=0)
231 |
232 |
233 | """Binary array data manipulation methods"""
234 |
235 |
236 | class binary(object):
237 | @staticmethod
238 | def parse(bstr):
239 | return [int(c) for c in bstr]
240 |
241 | @staticmethod
242 | def get(predictions):
243 | if predictions is Variable:
244 | predictions = predictions.data.cpu().numpy()
245 | return list(predictions.clip(min=0, max=1).round().astype(int))
246 |
247 | @staticmethod
248 | def str(vals):
249 | return "".join([str(x) for x in vals])
250 |
251 | @staticmethod
252 | def target(values):
253 | values = torch.tensor(values).float()
254 | return values.to(DEVICE)
255 |
256 | @staticmethod
257 | def redundant(values, n=3):
258 | return list(values) * n
259 |
260 | @staticmethod
261 | def consensus(values, n=3):
262 | return list((np.reshape(values, (n, -1)).mean(axis=0) >= 0.5).astype(int))
263 |
264 | @staticmethod
265 | def random(n=10):
266 | return [random.randint(0, 1) for i in range(0, n)]
267 |
268 | @staticmethod
269 | def distance(code1, code2):
270 | code1 = np.array(code1).clip(min=0, max=1).round()
271 | code2 = np.array(code2).clip(min=0, max=1).round()
272 | num = 0
273 | for i in range(len(code1)):
274 | if code1[i] != code2[i]:
275 | num += 1
276 | return num
277 |
278 | @staticmethod
279 | def mse_dist(code1, code2):
280 | a = np.array(code1)
281 | b = np.array(code2)
282 | return np.mean((a - b) ** 2)
283 |
284 |
285 | if __name__ == "__main__":
286 |
287 | data = im.load("test_data/n02108915_4657.jpg")
288 | im.save(data, file="out.jpg")
289 |
290 | print(im.torch(data).size())
291 | print(im.numpy(im.torch(data)).shape)
292 | im.save(im.numpy(im.torch(data)), file="out2.jpg")
293 |
294 | print(binary.consensus(binary.redundant([1, 1, 0, 1, 0, 0])))
295 | print(binary("111011"))
296 |
--------------------------------------------------------------------------------
/web/client/public/js/svg.js:
--------------------------------------------------------------------------------
1 | /*!
2 | * VERSION: 0.3.1
3 | * DATE: 2015-10-21
4 | * UPDATES AND DOCS AT: http://greensock.com
5 | *
6 | * @license Copyright (c) 2008-2015, GreenSock. All rights reserved.
7 | * MorphSVGPlugin is a Club GreenSock membership benefit; You must have a valid membership to use
8 | * this code without violating the terms of use. Visit http://greensock.com/club/ to sign up or get more details.
9 | * This work is subject to the software agreement that was issued with your membership.
10 | *
11 | * @author: Jack Doyle, jack@greensock.com
12 | */
13 | var _gsScope="undefined"!=typeof module&&module.exports&&"undefined"!=typeof global?global:this||window;(_gsScope._gsQueue||(_gsScope._gsQueue=[])).push(function(){"use strict";var a=Math.PI/180,b=180/Math.PI,c=/[achlmqstvz]|(-?\d*\.?\d*(?:e[\-+]?\d+)?)[0-9]/gi,d=/(?:(-|-=|\+=)?\d*\.?\d*(?:e[\-+]?\d+)?)[0-9]/gi,e=/[achlmqstvz]/gi,f=_gsScope.TweenLite,g=function(a){window.console&&console.log(a)},h=function(b,c){var d,e,f,g,h,i,j=Math.ceil(Math.abs(c)/90),k=0,l=[];for(b*=a,c*=a,d=c/j,e=4/3*Math.sin(d/2)/(1+Math.cos(d/2)),i=0;j>i;i++)f=b+i*d,g=Math.cos(f),h=Math.sin(f),l[k++]=g-e*h,l[k++]=h+e*g,f+=d,g=Math.cos(f),h=Math.sin(f),l[k++]=g+e*h,l[k++]=h-e*g,l[k++]=g,l[k++]=h;return l},i=function(c,d,e,f,g,i,j,k,l){if(c!==k||d!==l){e=Math.abs(e),f=Math.abs(f);var m=g%360*a,n=Math.cos(m),o=Math.sin(m),p=(c-k)/2,q=(d-l)/2,r=n*p+o*q,s=-o*p+n*q,t=e*e,u=f*f,v=r*r,w=s*s,x=v/t+w/u;x>1&&(e=Math.sqrt(x)*e,f=Math.sqrt(x)*f,t=e*e,u=f*f);var y=i===j?-1:1,z=(t*u-t*w-u*v)/(t*w+u*v);0>z&&(z=0);var A=y*Math.sqrt(z),B=A*(e*s/f),C=A*-(f*r/e),D=(c+k)/2,E=(d+l)/2,F=D+(n*B-o*C),G=E+(o*B+n*C),H=(r-B)/e,I=(s-C)/f,J=(-r-B)/e,K=(-s-C)/f,L=Math.sqrt(H*H+I*I),M=H;y=0>I?-1:1;var N=y*Math.acos(M/L)*b;L=Math.sqrt((H*H+I*I)*(J*J+K*K)),M=H*J+I*K,y=0>H*K-I*J?-1:1;var O=y*Math.acos(M/L)*b;!j&&O>0?O-=360:j&&0>O&&(O+=360),O%=360,N%=360;var P,Q,R,S=h(N,O),T=n*e,U=o*e,V=o*-f,W=n*f,X=S.length-2;for(P=0;X>P;P+=2)Q=S[P],R=S[P+1],S[P]=Q*T+R*V+F,S[P+1]=Q*U+R*W+G;return S[S.length-2]=k,S[S.length-1]=l,S}},j=function(a){var b,d,e,f,h,j,k,l,m,n,o,p,q,r=(a+"").match(c)||[],s=[],t=0,u=0,v=r.length,w=2,x=0;if(!a||!isNaN(r[0])||isNaN(r[1]))return g("ERROR: malformed path data: "+a),s;for(b=0;v>b;b++)if(q=h,isNaN(r[b])?(h=r[b].toUpperCase(),j=h!==r[b]):b--,e=+r[b+1],f=+r[b+2],j&&(e+=t,f+=u),0===b&&(l=e,m=f),"M"===h)t=l=e,u=m=f,k=[e,f],x+=w,w=2,s.push(k),b+=2;else if("C"===h)k||(k=[0,0]),k[w++]=e,k[w++]=f,j||(t=u=0),k[w++]=t+1*r[b+3],k[w++]=u+1*r[b+4],k[w++]=t+=1*r[b+5],k[w++]=u+=1*r[b+6],b+=6;else if("S"===h)"C"===q||"S"===q?(n=t-k[w-4],o=u-k[w-3],k[w++]=t+n,k[w++]=u+o):(k[w++]=t,k[w++]=u),k[w++]=e,k[w++]=f,j||(t=u=0),k[w++]=t+=1*r[b+3],k[w++]=u+=1*r[b+4],b+=4;else if("Q"===h)n=e-t,o=f-u,k[w++]=t+2*n/3,k[w++]=u+2*o/3,j||(t=u=0),t+=1*r[b+3],u+=1*r[b+4],n=e-t,o=f-u,k[w++]=t+2*n/3,k[w++]=u+2*o/3,k[w++]=t,k[w++]=u,b+=4;else if("T"===h)n=t-k[w-4],o=u-k[w-3],k[w++]=t+n,k[w++]=u+o,n=t+1.5*n-e,o=u+1.5*o-f,k[w++]=e+2*n/3,k[w++]=f+2*o/3,k[w++]=t=e,k[w++]=u=f,b+=2;else if("H"===h)f=u,k[w++]=t+(e-t)/3,k[w++]=u+(f-u)/3,k[w++]=t+2*(e-t)/3,k[w++]=u+2*(f-u)/3,k[w++]=t=e,k[w++]=f,b+=1;else if("V"===h)f=e,e=t,j&&(f+=u-t),k[w++]=e,k[w++]=u+(f-u)/3,k[w++]=e,k[w++]=u+2*(f-u)/3,k[w++]=e,k[w++]=u=f,b+=1;else if("L"===h||"Z"===h)"Z"===h&&(e=l,f=m,k.closed=!0),("L"===h||Math.abs(t-e)>1||Math.abs(u-f)>1)&&(k[w++]=t+(e-t)/3,k[w++]=u+(f-u)/3,k[w++]=t+2*(e-t)/3,k[w++]=u+2*(f-u)/3,k[w++]=e,k[w++]=f,b+=2),t=e,u=f;else if("A"===h){for(p=i(t,u,1*r[b+1],1*r[b+2],1*r[b+3],1*r[b+4],1*r[b+5],(j?t:0)+1*r[b+6],(j?u:0)+1*r[b+7]),d=0;d