Offline gym log for Android. No account, no ads, no internet.
Dart androidbodybuildingdartexercisesf-droidfitnessfluttergymgym-apphealthprivacyself-hostedworkoutworkout-appworkout-tracker
import 'dart:async';
import 'dart:math' as math;
import 'dart:ui' as ui;
import 'package:flutter/foundation.dart';
class StickerResult {
const StickerResult(this.png, {required this.cut});
final Uint8List png;
final bool cut;
}
Future<StickerResult?> makeSticker(Uint8List source, {bool cutout = true}) async {
final rgba = await _decode(source, 900);
if (rgba == null) return null;
final out = await compute(_process, (rgba.$1, rgba.$2, rgba.$3, cutout));
final cut = out.$4;
final png = await _encode(out.$1, out.$2, out.$3);
return png == null ? null : StickerResult(png, cut: cut);
}
class CutoutDraft {
const CutoutDraft(this.width, this.height, this.rgba, this.mask, {required this.auto, required this.found});
final int width;
final int height;
final Uint8List rgba;
final Uint8List mask;
final Uint8List auto;
final bool found;
CutoutDraft withMask(Uint8List next) => CutoutDraft(width, height, rgba, next, auto: auto, found: found);
}
Future<CutoutDraft?> prepareCutout(Uint8List source) async {
final rgba = await _decode(source, 900);
if (rgba == null) return null;
final mask = await compute(_draftMask, rgba);
final (w, h, px) = rgba;
final start = mask ?? (Uint8List(w * h)..fillRange(0, w * h, 1));
return CutoutDraft(w, h, px, start, auto: start, found: mask != null);
}
Uint8List? _draftMask((int, int, Uint8List) args) {
final (w, h, src) = args;
return cutoutMask(w, h, src) ?? cutoutMask(w, h, src, force: true);
}
Future<Uint8List?> renderSticker(CutoutDraft draft, Uint8List mask) async {
var any = false;
for (final v in mask) {
if (v != 0) {
any = true;
break;
}
}
if (!any) return null;
final out = await compute(_renderMasked, (draft.width, draft.height, draft.rgba, mask));
return _encode(out.$1, out.$2, out.$3);
}
(int, int, Uint8List, bool) _renderMasked((int, int, Uint8List, Uint8List) args) {
final (w, h, src, mask) = args;
final clean = Uint8List.fromList(mask);
_open(clean, w, h);
return _outlined(w, h, src, clean);
}
Future<Uint8List> regionAt(CutoutDraft draft, int x, int y) =>
compute(_region, (draft.width, draft.height, draft.rgba, x, y));
Uint8List _region((int, int, Uint8List, int, int) args) {
final (w, h, src, x0, y0) = args;
final n = w * h;
final y = Float32List(n), cb = Float32List(n), cr = Float32List(n);
for (var i = 0; i < n; i++) {
final r = src[i * 4].toDouble(), g = src[i * 4 + 1].toDouble(), b = src[i * 4 + 2].toDouble();
final l = 0.299 * r + 0.587 * g + 0.114 * b;
y[i] = l;
cb[i] = b - l;
cr[i] = r - l;
}
final wall = _edges(y, w, h);
_blur(y, w, h);
_blur(cb, w, h);
_blur(cr, w, h);
final seed = y0.clamp(0, h - 1) * w + x0.clamp(0, w - 1);
double diff(int a, int b) {
final dy = y[a] - y[b], db = cb[a] - cb[b], dr = cr[a] - cr[b];
return math.sqrt(0.3 * dy * dy + db * db + dr * dr);
}
final out = Uint8List(n);
final queue = Int32List(n);
var head = 0, tail = 0;
out[seed] = 1;
queue[tail++] = seed;
while (head < tail) {
final p = queue[head++];
final px = p % w, py = p ~/ w;
for (final q in [
if (px > 0) p - 1,
if (px < w - 1) p + 1,
if (py > 0) p - w,
if (py < h - 1) p + w,
]) {
if (out[q] != 0) continue;
if (diff(q, seed) <= 34 && diff(p, q) <= 10 && (wall[q] == 0 || diff(q, seed) <= 14)) {
out[q] = 1;
queue[tail++] = q;
}
}
}
for (var pass = 0; pass < 2; pass++) {
final grow = <int>[];
for (var i = 0; i < n; i++) {
if (out[i] != 0) continue;
final px = i % w, py = i ~/ w;
if ((px > 0 && out[i - 1] != 0) ||
(px < w - 1 && out[i + 1] != 0) ||
(py > 0 && out[i - w] != 0) ||
(py < h - 1 && out[i + w] != 0)) {
grow.add(i);
}
}
for (final i in grow) {
out[i] = 1;
}
}
_fillHoles(out, w, h);
return out;
}
Future<(int, int, Uint8List)?> _decode(Uint8List bytes, int maxSide) async {
try {
final probe = await ui.instantiateImageCodec(bytes);
final first = (await probe.getNextFrame()).image;
final w = first.width, h = first.height;
final scale = math.min(1.0, maxSide / math.max(w, h));
ui.Image image = first;
if (scale < 1) {
first.dispose();
final codec = await ui.instantiateImageCodec(bytes,
targetWidth: (w * scale).round(), targetHeight: (h * scale).round());
image = (await codec.getNextFrame()).image;
}
final data = await image.toByteData(format: ui.ImageByteFormat.rawStraightRgba);
final result = (image.width, image.height, data!.buffer.asUint8List());
image.dispose();
return result;
} catch (_) {
return null;
}
}
Future<Uint8List?> _encode(int w, int h, Uint8List rgba) async {
final done = Completer<ui.Image>();
ui.decodeImageFromPixels(rgba, w, h, ui.PixelFormat.rgba8888, done.complete);
final image = await done.future;
final png = await image.toByteData(format: ui.ImageByteFormat.png);
image.dispose();
return png?.buffer.asUint8List();
}
(int, int, Uint8List, bool) _process((int, int, Uint8List, bool) args) {
final (w, h, src, wantCut) = args;
final mask = wantCut ? (cutoutMask(w, h, src) ?? cutoutMask(w, h, src, force: true)) : null;
return mask == null ? _framed(w, h, src) : _outlined(w, h, src, mask);
}
@visibleForTesting
Uint8List? cutoutMask(int w, int h, Uint8List src, {bool force = false}) {
final n = w * h;
final y = Float32List(n), cb = Float32List(n), cr = Float32List(n);
for (var i = 0; i < n; i++) {
final r = src[i * 4].toDouble(), g = src[i * 4 + 1].toDouble(), b = src[i * 4 + 2].toDouble();
final l = 0.299 * r + 0.587 * g + 0.114 * b;
y[i] = l;
cb[i] = b - l;
cr[i] = r - l;
}
final wall = _edges(y, w, h);
_blur(y, w, h);
_blur(cb, w, h);
_blur(cr, w, h);
double dist(int a, int b) {
final dy = y[a] - y[b], db = cb[a] - cb[b], dr = cr[a] - cr[b];
return math.sqrt(0.3 * dy * dy + db * db + dr * dr);
}
final border = <int>[];
for (var x = 0; x < w; x++) {
border..add(x)..add((h - 1) * w + x);
}
for (var r = 1; r < h - 1; r++) {
border..add(r * w)..add(r * w + w - 1);
}
final my = _median([for (final i in border) y[i]]);
final mb = _median([for (final i in border) cb[i]]);
final mr = _median([for (final i in border) cr[i]]);
double toBg(int i) {
final dy = y[i] - my, db = cb[i] - mb, dr = cr[i] - mr;
return math.sqrt(0.3 * dy * dy + db * db + dr * dr);
}
final spread = [for (final i in border) toBg(i)]..sort();
final p80 = spread[(spread.length * 0.8).floor().clamp(0, spread.length - 1)];
if (p80 > 30 && !force) return null;
final seedLimit = (p80 * 1.5 + 14).clamp(18.0, 60.0);
final globalLimit = seedLimit * 1.9;
const step = 9.0;
bool shadow(int i) {
final db = cb[i] - mb, dr = cr[i] - mr;
return db * db + dr * dr < 64 && y[i] < my && y[i] > my * 0.5;
}
final bg = Uint8List(n);
final queue = Int32List(n);
var head = 0, tail = 0;
for (final i in border) {
if (bg[i] == 0 && toBg(i) <= seedLimit) {
bg[i] = 1;
queue[tail++] = i;
}
}
if (tail < border.length * (force ? 0.05 : 0.35)) return null;
while (head < tail) {
final p = queue[head++];
final px = p % w, py = p ~/ w;
for (final q in [
if (px > 0) p - 1,
if (px < w - 1) p + 1,
if (py > 0) p - w,
if (py < h - 1) p + w,
]) {
if (bg[q] != 0 || wall[q] != 0) continue;
if (dist(p, q) <= step && (toBg(q) <= globalLimit || shadow(q))) {
bg[q] = 1;
queue[tail++] = q;
}
}
}
for (var pass = 0; pass < 3; pass++) {
final grow = <int>[];
for (var i = 0; i < n; i++) {
if (bg[i] != 0 || wall[i] == 0 || toBg(i) > globalLimit) continue;
final px = i % w, py = i ~/ w;
if ((px > 0 && bg[i - 1] != 0) ||
(px < w - 1 && bg[i + 1] != 0) ||
(py > 0 && bg[i - w] != 0) ||
(py < h - 1 && bg[i + w] != 0)) {
grow.add(i);
}
}
for (final i in grow) {
bg[i] = 1;
}
}
final fg = Uint8List(n);
for (var i = 0; i < n; i++) {
fg[i] = bg[i] == 0 ? 1 : 0;
}
_open(fg, w, h);
_open(fg, w, h);
_keepMain(fg, w, h);
_fillHoles(fg, w, h, keep: (i) => toBg(i) <= seedLimit, minHole: (n * 0.002).round());
var edge = 0;
for (final i in border) {
edge += fg[i];
}
if (edge > border.length * (force ? 0.6 : 0.2)) return null;
var area = 0;
for (var i = 0; i < n; i++) {
area += fg[i];
}
final share = area / n;
if (share < (force ? 0.02 : 0.04) || share > (force ? 0.97 : 0.93)) return null;
return fg;
}
(int, int, Uint8List, bool) _framed(int w, int h, Uint8List src) {
final side = math.min(w, h);
final ox = (w - side) ~/ 2, oy = (h - side) ~/ 2;
final crop = Uint8List(side * side * 4);
for (var r = 0; r < side; r++) {
final from = ((oy + r) * w + ox) * 4;
crop.setRange(r * side * 4, (r + 1) * side * 4, src, from);
}
final mask = Uint8List(side * side);
final radius = side * 0.16;
for (var r = 0; r < side; r++) {
for (var c = 0; c < side; c++) {
final dx = math.max(0.0, math.max(radius - c, c - (side - 1 - radius)));
final dy = math.max(0.0, math.max(radius - r, r - (side - 1 - radius)));
mask[r * side + c] = dx * dx + dy * dy <= radius * radius ? 1 : 0;
}
}
return _outlined(side, side, crop, mask, cut: false);
}
(int, int, Uint8List, bool) _outlined(int w, int h, Uint8List src, Uint8List mask, {bool cut = true}) {
var x0 = w, y0 = h, x1 = -1, y1 = -1;
for (var r = 0; r < h; r++) {
for (var c = 0; c < w; c++) {
if (mask[r * w + c] == 0) continue;
if (c < x0) x0 = c;
if (c > x1) x1 = c;
if (r < y0) y0 = r;
if (r > y1) y1 = r;
}
}
final bw = x1 - x0 + 1, bh = y1 - y0 + 1;
final ring = math.max(5, (math.max(bw, bh) * 0.035).round());
final pad = ring + 3;
final ow = bw + pad * 2, oh = bh + pad * 2;
final alpha = Float32List(ow * oh);
final inside = Uint8List(ow * oh);
for (var r = 0; r < bh; r++) {
for (var c = 0; c < bw; c++) {
if (mask[(y0 + r) * w + x0 + c] == 1) inside[(r + pad) * ow + c + pad] = 1;
}
}
for (var r = 1; r < oh - 1; r++) {
for (var c = 1; c < ow - 1; c++) {
var s = 0;
for (var dy = -1; dy <= 1; dy++) {
for (var dx = -1; dx <= 1; dx++) {
s += inside[(r + dy) * ow + c + dx];
}
}
alpha[r * ow + c] = inside[r * ow + c] == 1 ? (s >= 9 ? 1.0 : 0.55 + s / 20) : (s > 0 ? s / 18 : 0);
}
}
final dist = _distance(inside, ow, oh);
final out = Uint8List(ow * oh * 4);
for (var r = 0; r < oh; r++) {
for (var c = 0; c < ow; c++) {
final o = r * ow + c;
final a = alpha[o].clamp(0.0, 1.0);
final ring01 = (ring - dist[o] + 0.5).clamp(0.0, 1.0);
final total = a + ring01 * (1 - a);
if (total <= 0) continue;
final sr = r - pad + y0, sc = c - pad + x0;
final inImg = sr >= 0 && sr < h && sc >= 0 && sc < w;
final si = inImg ? (sr * w + sc) * 4 : 0;
for (var k = 0; k < 3; k++) {
final s = inImg ? src[si + k].toDouble() : 255.0;
out[o * 4 + k] = ((s * a + 255 * ring01 * (1 - a)) / total).round().clamp(0, 255);
}
out[o * 4 + 3] = (total * 255).round().clamp(0, 255);
}
}
return (ow, oh, out, cut);
}
Uint8List _edges(Float32List y, int w, int h) {
final g = Float32List(w * h);
for (var r = 1; r < h - 1; r++) {
for (var c = 1; c < w - 1; c++) {
final i = r * w + c;
final gx = y[i - w + 1] + 2 * y[i + 1] + y[i + w + 1] - y[i - w - 1] - 2 * y[i - 1] - y[i + w - 1];
final gy = y[i + w - 1] + 2 * y[i + w] + y[i + w + 1] - y[i - w - 1] - 2 * y[i - w] - y[i - w + 1];
g[i] = math.sqrt(gx * gx + gy * gy);
}
}
const limit = 28.0;
final hard = Uint8List(w * h);
for (var i = 0; i < g.length; i++) {
if (g[i] > limit) hard[i] = 1;
}
final wall = Uint8List(w * h);
for (var r = 1; r < h - 1; r++) {
for (var c = 1; c < w - 1; c++) {
final i = r * w + c;
wall[i] = hard[i] | hard[i - 1] | hard[i + 1] | hard[i - w] | hard[i + w];
}
}
return wall;
}
void _blur(Float32List v, int w, int h) {
final tmp = Float32List(v.length);
for (var r = 0; r < h; r++) {
for (var c = 0; c < w; c++) {
final a = v[r * w + math.max(0, c - 1)], b = v[r * w + c], d = v[r * w + math.min(w - 1, c + 1)];
tmp[r * w + c] = (a + b + d) / 3;
}
}
for (var r = 0; r < h; r++) {
for (var c = 0; c < w; c++) {
final a = tmp[math.max(0, r - 1) * w + c], b = tmp[r * w + c], d = tmp[math.min(h - 1, r + 1) * w + c];
v[r * w + c] = (a + b + d) / 3;
}
}
}
double _median(List<double> xs) {
xs.sort();
return xs[xs.length ~/ 2];
}
void _open(Uint8List m, int w, int h) {
final e = Uint8List(m.length);
for (var r = 1; r < h - 1; r++) {
for (var c = 1; c < w - 1; c++) {
final i = r * w + c;
e[i] = m[i] & m[i - 1] & m[i + 1] & m[i - w] & m[i + w];
}
}
for (var r = 1; r < h - 1; r++) {
for (var c = 1; c < w - 1; c++) {
final i = r * w + c;
m[i] = e[i] | e[i - 1] | e[i + 1] | e[i - w] | e[i + w];
}
}
}
void _keepMain(Uint8List m, int w, int h) {
final label = Int32List(m.length);
final sizes = <int>[0];
final touch = <int>[0];
final sx = <double>[0], sy = <double>[0];
final queue = Int32List(m.length);
for (var i = 0; i < m.length; i++) {
if (m[i] == 0 || label[i] != 0) continue;
final id = sizes.length;
var head = 0, tail = 0, count = 0, edge = 0;
var ax = 0.0, ay = 0.0;
label[i] = id;
queue[tail++] = i;
while (head < tail) {
final p = queue[head++];
count++;
final px = p % w, py = p ~/ w;
ax += px;
ay += py;
if (px == 0 || py == 0 || px == w - 1 || py == h - 1) edge++;
for (final q in [
if (px > 0) p - 1,
if (px < w - 1) p + 1,
if (py > 0) p - w,
if (py < h - 1) p + w,
]) {
if (m[q] == 1 && label[q] == 0) {
label[q] = id;
queue[tail++] = q;
}
}
}
sizes.add(count);
touch.add(edge);
sx.add(ax / count);
sy.add(ay / count);
}
if (sizes.length <= 1) return;
final perimeter = 2 * (w + h);
double score(int id) {
final dx = (sx[id] - w / 2) / (w / 2), dy = (sy[id] - h / 2) / (h / 2);
final centred = 1 - 0.55 * math.min(1.0, math.sqrt(dx * dx + dy * dy));
final edgy = touch[id] > perimeter * 0.03 ? 0.4 : 1.0;
return sizes[id] * centred * edgy;
}
var best = 1;
for (var id = 2; id < sizes.length; id++) {
if (score(id) > score(best)) best = id;
}
final keep = Uint8List(sizes.length);
for (var id = 1; id < sizes.length; id++) {
keep[id] = id == best || (sizes[id] >= sizes[best] * 0.15 && touch[id] <= perimeter * 0.01) ? 1 : 0;
}
for (var i = 0; i < m.length; i++) {
if (m[i] == 1 && keep[label[i]] == 0) m[i] = 0;
}
}
void _fillHoles(Uint8List m, int w, int h, {bool Function(int)? keep, int minHole = 0}) {
final out = Uint8List(m.length);
final queue = Int32List(m.length);
var head = 0, tail = 0;
void seed(int i) {
if (m[i] == 0 && out[i] == 0) {
out[i] = 1;
queue[tail++] = i;
}
}
for (var x = 0; x < w; x++) {
seed(x);
seed((h - 1) * w + x);
}
for (var r = 0; r < h; r++) {
seed(r * w);
seed(r * w + w - 1);
}
void spread(void Function(int) visit) {
while (head < tail) {
final p = queue[head++];
final px = p % w, py = p ~/ w;
if (px > 0) visit(p - 1);
if (px < w - 1) visit(p + 1);
if (py > 0) visit(p - w);
if (py < h - 1) visit(p + w);
}
}
spread(seed);
final hole = Int32List(m.length);
for (var i = 0; i < m.length; i++) {
if (m[i] != 0 || out[i] != 0) continue;
if (keep == null) {
m[i] = 1;
continue;
}
head = 0;
tail = 0;
var size = 0, open = 0;
void grow(int q) {
if (m[q] == 0 && out[q] == 0) {
out[q] = 2;
queue[tail++] = q;
hole[size++] = q;
if (keep(q)) open++;
}
}
grow(i);
spread(grow);
final clear = size >= minHole && open >= size * 0.8;
if (!clear) {
for (var k = 0; k < size; k++) {
m[hole[k]] = 1;
}
}
}
}
Float32List _distance(Uint8List inside, int w, int h) {
const big = 1e9;
final d = Float32List(w * h);
for (var i = 0; i < d.length; i++) {
d[i] = inside[i] == 1 ? 0 : big;
}
const a = 1.0, b = 1.4142;
for (var r = 0; r < h; r++) {
for (var c = 0; c < w; c++) {
final i = r * w + c;
var v = d[i];
if (c > 0) v = math.min(v, d[i - 1] + a);
if (r > 0) {
v = math.min(v, d[i - w] + a);
if (c > 0) v = math.min(v, d[i - w - 1] + b);
if (c < w - 1) v = math.min(v, d[i - w + 1] + b);
}
d[i] = v;
}
}
for (var r = h - 1; r >= 0; r--) {
for (var c = w - 1; c >= 0; c--) {
final i = r * w + c;
var v = d[i];
if (c < w - 1) v = math.min(v, d[i + 1] + a);
if (r < h - 1) {
v = math.min(v, d[i + w] + a);
if (c < w - 1) v = math.min(v, d[i + w + 1] + b);
if (c > 0) v = math.min(v, d[i + w - 1] + b);
}
d[i] = v;
}
}
return d;
}