Spaces:

MikePGxAI
/

artwall

Running

App Files Files Community

MikePGxAI commited on Dec 22, 2025

Commit

3893a2b

verified ·

1 Parent(s): 2f120b8

Upload 4 files

Browse files

Files changed (4) hide show

Dockerfile +21 -0
index.html +238 -0
requirements.txt +8 -0
server.py +312 -0

Dockerfile ADDED Viewed

	@@ -0,0 +1,21 @@

+FROM python:3.12-slim
+ENV PYTHONDONTWRITEBYTECODE=1
+ENV PYTHONUNBUFFERED=1
+# Cache locations (helpful if you later enable persistent storage)
+ENV HF_HOME=/data/.huggingface
+ENV TRANSFORMERS_CACHE=/data/.huggingface/transformers
+ENV HF_HUB_CACHE=/data/.huggingface/hub
+WORKDIR /app
+COPY requirements.txt /app/requirements.txt
+RUN pip install --upgrade pip && pip install -r requirements.txt
+COPY server.py /app/server.py
+COPY index.html /app/index.html
+EXPOSE 7860
+CMD ["python","-m","uvicorn","server:app","--host","0.0.0.0","--port","7860","--log-level","info"]

index.html ADDED Viewed

	@@ -0,0 +1,238 @@

+<!doctype html>
+<html lang="ru">
+<head>
+  <meta charset="utf-8" />
+  <meta name="viewport" content="width=device-width,initial-scale=1" />
+  <title>AI Artwall</title>
+  <style>
+    html, body { width:100%; height:100%; margin:0; background:#000; overflow:hidden; }
+    canvas { width:100vw; height:100vh; display:block; }
+    #hint {
+      position: fixed;
+      left: 16px; bottom: 12px;
+      font: 12px/1.2 system-ui, -apple-system, Segoe UI, Roboto, Arial;
+      color: rgba(255,255,255,0.45);
+      user-select: none;
+      pointer-events: none;
+    }
+  </style>
+</head>
+<body>
+  <canvas id="c"></canvas>
+  <div id="hint">Клик: fullscreen • /health: статус</div>
+<script>
+  const API_NEXT = "/next";
+  const FADE_MS  = 1600;
+  const TRANSITION = "dissolve";
+  // Медленное, монотонное отдаление
+  // Попробуйте: 20000 (20с) / 30000 (30с) / 45000 (45с)
+  const DRIFT_MS = 20000;
+  // Насколько “близко” стартуем
+  // 1.08–1.18 обычно выглядит естественно
+  const ZOOM_FROM = 1.14;
+  const ZOOM_TO   = 1.00;
+  const MASK_SIZE = 256;
+  const DPR_MAX = 2;
+  const canvas = document.getElementById("c");
+  const ctx = canvas.getContext("2d", { alpha: false });
+  const buf = document.createElement("canvas");
+  const bctx = buf.getContext("2d", { alpha: true });
+  function resize() {
+    const dpr = Math.min(window.devicePixelRatio || 1, DPR_MAX);
+    canvas.width  = Math.floor(innerWidth  * dpr);
+    canvas.height = Math.floor(innerHeight * dpr);
+    ctx.imageSmoothingEnabled = true;
+    ctx.imageSmoothingQuality = "high";
+    buf.width = canvas.width;
+    buf.height = canvas.height;
+  }
+  addEventListener("resize", resize);
+  resize();
+  const maskCanvas = document.createElement("canvas");
+  maskCanvas.width = MASK_SIZE;
+  maskCanvas.height = MASK_SIZE;
+  const mctx = maskCanvas.getContext("2d", { willReadFrequently: true });
+  const maskData = mctx.createImageData(MASK_SIZE, MASK_SIZE);
+  const noise = new Uint8Array(MASK_SIZE * MASK_SIZE);
+  (crypto || window.crypto).getRandomValues(noise);
+  function regenNoise() {
+    (crypto || window.crypto).getRandomValues(noise);
+  }
+  function updateMask(progress01) {
+    const t = Math.max(0, Math.min(255, Math.floor(progress01 * 255)));
+    const d = maskData.data;
+    for (let i = 0, p = 0; i < noise.length; i++, p += 4) {
+      const a = (noise[i] < t) ? 255 : 0;
+      d[p] = 255; d[p+1] = 255; d[p+2] = 255; d[p+3] = a;
+    }
+    mctx.putImageData(maskData, 0, 0);
+  }
+  function blobToImage(blob) {
+    return new Promise((resolve, reject) => {
+      const url = URL.createObjectURL(blob);
+      const img = new Image();
+      img.onload = () => { URL.revokeObjectURL(url); resolve(img); };
+      img.onerror = (e) => { URL.revokeObjectURL(url); reject(e); };
+      img.src = url;
+    });
+  }
+  async function fetchNext() {
+    const r = await fetch(API_NEXT, { cache: "no-store" });
+    if (!r.ok) throw new Error("fetch /next failed: " + r.status);
+    const id = Number(r.headers.get("x-frame-id") || "0");
+    const blob = await r.blob();
+    const img = await blobToImage(blob);
+    return { id, img };
+  }
+  let current = null;
+  let incoming = null;
+  let swapping = false;
+  let fadeStart = 0;
+  // ВАЖНО: отдельные “старты отдаления” для текущей и входящей картинки
+  let driftStartCurrent = performance.now();
+  let driftStartIncoming = performance.now();
+  function clamp01(x){ return Math.max(0, Math.min(1, x)); }
+  function easeInOut(x){
+    x = clamp01(x);
+    return x * x * (3 - 2 * x); // smoothstep
+  }
+  function coverDraw(targetCtx, img, alpha, zoom) {
+    const cw = targetCtx.canvas.width;
+    const ch = targetCtx.canvas.height;
+    const iw = img.naturalWidth  || img.width;
+    const ih = img.naturalHeight || img.height;
+    const s = Math.max(cw / iw, ch / ih) * zoom;
+    const w = iw * s, h = ih * s;
+    const x = (cw - w) * 0.5;
+    const y = (ch - h) * 0.5;
+    targetCtx.globalAlpha = alpha;
+    targetCtx.drawImage(img, x, y, w, h);
+    targetCtx.globalAlpha = 1;
+  }
+  function drawLoading(now) {
+    ctx.fillStyle = "#000";
+    ctx.fillRect(0, 0, canvas.width, canvas.height);
+    const t = (Math.sin(now / 450) * 0.5 + 0.5);
+    ctx.fillStyle = `rgba(255,255,255,${0.22 + 0.22 * t})`;
+    ctx.font = `${Math.floor(canvas.width / 40)}px system-ui, -apple-system, Segoe UI, Roboto, Arial`;
+    ctx.textAlign = "center";
+    ctx.textBaseline = "middle";
+    ctx.fillText("Генерация…", canvas.width/2, canvas.height/2);
+  }
+  function zoomFor(now, driftStart) {
+    const k = easeInOut(clamp01((now - driftStart) / DRIFT_MS));
+    return ZOOM_FROM + (ZOOM_TO - ZOOM_FROM) * k;
+  }
+  function tick(now) {
+    if (!current) {
+      drawLoading(now);
+      requestAnimationFrame(tick);
+      return;
+    }
+    ctx.fillStyle = "#000";
+    ctx.fillRect(0, 0, canvas.width, canvas.height);
+    const zoomCurrent = zoomFor(now, driftStartCurrent);
+    coverDraw(ctx, current.img, 1, zoomCurrent);
+    if (swapping && incoming) {
+      const t = clamp01((now - fadeStart) / FADE_MS);
+      const e = easeInOut(t);
+      // Входящая картинка отдаляется со своего старта (без скачка после перехода)
+      const zoomIncoming = zoomFor(now, driftStartIncoming);
+      if (TRANSITION === "fade") {
+        coverDraw(ctx, incoming.img, e, zoomIncoming);
+      } else {
+        updateMask(e);
+        bctx.clearRect(0, 0, buf.width, buf.height);
+        bctx.globalCompositeOperation = "source-over";
+        bctx.drawImage(maskCanvas, 0, 0, buf.width, buf.height);
+        bctx.globalCompositeOperation = "source-in";
+        coverDraw(bctx, incoming.img, 1, zoomIncoming);
+        ctx.drawImage(buf, 0, 0);
+      }
+      if (t >= 1) {
+        // commit swap — и ВАЖНО: не сбрасываем drift заново, а переносим его
+        current = incoming;
+        incoming = null;
+        swapping = false;
+        driftStartCurrent = driftStartIncoming; // никаких резких “приближений”
+        regenNoise();
+      }
+    }
+    requestAnimationFrame(tick);
+  }
+  async function run() {
+    while (true) {
+      try {
+        const fr = await fetchNext();
+        if (!current) {
+          current = fr;
+          driftStartCurrent = performance.now();
+          requestAnimationFrame(tick);
+          continue;
+        }
+        incoming = fr;
+        if (!swapping) {
+          swapping = true;
+          const now = performance.now();
+          fadeStart = now;
+          driftStartIncoming = now; // входящая сразу стартует “ближе” и начинает отдаляться
+        }
+      } catch (e) {
+        console.error(e);
+        await new Promise(r => setTimeout(r, 1000));
+      }
+    }
+  }
+  document.addEventListener("click", () => {
+    if (!document.fullscreenElement) {
+      document.documentElement.requestFullscreen?.().catch(() => {});
+    }
+  });
+  run();
+</script>
+</body>
+</html>

requirements.txt ADDED Viewed

	@@ -0,0 +1,8 @@

+fastapi==0.115.6
+uvicorn[standard]==0.32.1
+pillow==10.4.0
+torch
+diffusers==0.30.3
+transformers==4.45.2
+accelerate
+safetensors==0.4.5

server.py ADDED Viewed

	@@ -0,0 +1,312 @@

+import io
+import os
+import random
+import threading
+import time
+from queue import Queue, Empty
+import torch
+from fastapi import FastAPI, Response
+from fastapi.responses import JSONResponse, HTMLResponse
+from fastapi.middleware.cors import CORSMiddleware
+from diffusers import AutoPipelineForText2Image
+from PIL import Image
+MODEL_ID = os.getenv("MODEL_ID", "stabilityai/sd-turbo")
+W = int(os.getenv("W", "640"))
+H = int(os.getenv("H", "640"))
+STEPS = int(os.getenv("STEPS", "6"))
+GUIDANCE = float(os.getenv("GUIDANCE", "1.5"))
+USE_FP32_ON_MPS = os.getenv("USE_FP32_ON_MPS", "1") == "1"
+QUEUE_MAX = int(os.getenv("QUEUE_MAX", "2"))
+# Epoch distribution
+# 50%: Impressionism+ → Contemporary
+# 30%: Early Renaissance → Romanticism
+# 20%: Pre-Gothic / Medieval / Gothic / Icon-like
+P_MODERN = float(os.getenv("P_MODERN", "0.50"))
+P_CLASSIC = float(os.getenv("P_CLASSIC", "0.30"))
+P_EARLY = float(os.getenv("P_EARLY", "0.20"))
+# Content balance
+CLASSIC_PEOPLE_WEIGHT = float(os.getenv("CLASSIC_PEOPLE_WEIGHT", "0.60"))  # in classic 30%, more portraits/figures than landscapes
+MODERN_PEOPLE_WEIGHT = float(os.getenv("MODERN_PEOPLE_WEIGHT", "0.35"))    # in modern 50%, fewer faces (helps with hands)
+# Strong "no frame" enforcement
+NEGATIVE = (
+    # Kill frames / borders / museum context
+    "frame, picture frame, painting frame, ornate frame, gold frame, "
+    "border, canvas edge, cropped canvas, mat, passepartout, "
+    "gallery wall, museum wall, hanging painting, framed artwork, "
+    "wood frame, gilded frame, edge of painting, "
+    # Kill text/logos
+    "text, watermark, logo, signature, letters, "
+    # Safety
+    "nsfw, nude, naked, porn, gore, violence, "
+    # Quality
+    "blur, blurry, out of focus, lowres, jpeg artifacts, "
+    # Anatomy (but do NOT force hands in positive prompt)
+    "bad anatomy, bad proportions, bad face, deformed face, "
+    "bad hands, malformed hands, deformed hands, "
+    "extra fingers, missing fingers, fused fingers, extra limbs, "
+    "hands in foreground, close-up hands, cropped hands, "
+    # Avoid photo/CGI look
+    "photorealistic, hyperrealistic, cgi, 3d render, plastic skin, anime, cartoon"
+)
+# ---- Prompt building blocks ----
+BASE_PAINTING_QUALITY = (
+    "fine art painting, museum-quality artwork, painterly, expressive brushwork, "
+    "coherent artistic style, unified composition, natural color harmony, "
+    "sharp focus, high detail, canvas texture subtle, "
+    "no frame, no border, no canvas edge, "
+    "no photographic realism"
+)
+COMPOSITION_CALM = (
+    "balanced composition, calm pose, medium shot, hands not emphasized, "
+    "hands partially obscured by clothing or out of frame, "
+    "no dramatic hand gestures, hands not in foreground"
+)
+LIGHTING_SOFT = "soft natural light, gentle contrast, pleasing tonal range"
+LIGHTING_DRAMATIC = "dramatic chiaroscuro, deep shadows, warm highlights"
+# ---- 20% Early (pre-gothic / medieval / gothic / icons) ----
+EARLY_POOL = [
+    "early medieval illuminated manuscript style, flat composition, symbolic forms, tempera, muted pigments",
+    "byzantine icon painting style, gold leaf tones, sacred atmosphere, stylized features, tempera on wood",
+    "gothic panel painting style, elongated forms, ornate patterns, flat background, tempera",
+    "romanese mural painting style, fresco texture, simplified figures, symbolic composition",
+    "medieval devotional painting style, stylized drapery, flat shapes, decorative borders implied (but no frame)",
+]
+# ---- 30% Classic (early renaissance → romanticism) ----
+CLASSIC_PEOPLE = [
+    "early renaissance oil painting portrait, sfumato, subtle realism, classical balance",
+    "high renaissance portrait painting, refined anatomy, calm expression, old master",
+    "baroque oil painting figure scene, rich pigments, theatrical lighting",
+    "dutch golden age interior scene painting, soft window light, oil on canvas",
+    "romanticism portrait painting, warm skin tones, painterly texture, emotional mood",
+]
+CLASSIC_LANDSCAPES = [
+    "renaissance landscape painting, atmospheric perspective, classical composition",
+    "baroque landscape painting, dramatic sky, warm highlights, painterly",
+    "romantic landscape painting, luminous clouds, distant horizon, oil on canvas",
+    "classical pastoral landscape painting, soft light, calm mood, painterly",
+]
+# ---- 50% Modern+ (impressionism → postimpressionism → modern → contemporary) ----
+MODERN_PEOPLE = [
+    "impressionist portrait painting, visible brush strokes, light and color, soft edges",
+    "post-impressionist portrait painting, structured brushwork, rich color, painterly",
+    "fauvism portrait painting, bold color harmony, simplified shapes, expressive",
+    "expressionist figure painting, energetic brushwork, emotional color, painterly",
+    "modern figurative painting, simplified forms, contemporary palette, painterly",
+]
+MODERN_LANDSCAPES = [
+    "impressionist landscape painting, plein air, shimmering light, visible brush strokes",
+    "post-impressionist landscape painting, vibrant color, structured strokes, painterly",
+    "fauvism landscape painting, bold color fields, simplified forms, expressive",
+    "modern abstract landscape-inspired painting, color fields, texture, painterly",
+    "contemporary painting, abstract forms, subtle glitch-like texture, mixed media feel (still painterly)",
+    "minimal color-field painting, soft gradients, subtle texture, contemporary art",
+]
+def weighted_choice(groups):
+    r = random.random()
+    acc = 0.0
+    for p, name in groups:
+        acc += p
+        if r <= acc:
+            return name
+    return groups[-1][1]
+def pick_epoch_group():
+    total = P_MODERN + P_CLASSIC + P_EARLY
+    if total <= 0:
+        return "modern"
+    pm = P_MODERN / total
+    pc = P_CLASSIC / total
+    pe = P_EARLY / total
+    return weighted_choice([(pm, "modern"), (pc, "classic"), (pe, "early")])
+def pick_prompt():
+    epoch = pick_epoch_group()
+    if epoch == "early":
+        style = random.choice(EARLY_POOL)
+        lighting = LIGHTING_SOFT
+        comp = "balanced composition, icon-like calm, no frame, no border"
+        return f"{style}, {BASE_PAINTING_QUALITY}, {lighting}, {comp}"
+    if epoch == "classic":
+        if random.random() < CLASSIC_PEOPLE_WEIGHT:
+            style = random.choice(CLASSIC_PEOPLE)
+            lighting = random.choice([LIGHTING_SOFT, LIGHTING_DRAMATIC])
+            comp = COMPOSITION_CALM
+        else:
+            style = random.choice(CLASSIC_LANDSCAPES)
+            lighting = random.choice([LIGHTING_SOFT, LIGHTING_DRAMATIC])
+            comp = "balanced composition, no frame, no border"
+        return f"{style}, {BASE_PAINTING_QUALITY}, {lighting}, {comp}"
+    # modern (50%)
+    # Reduce hands/faces issues by favoring landscapes/abstract more often
+    if random.random() < MODERN_PEOPLE_WEIGHT:
+        style = random.choice(MODERN_PEOPLE)
+        comp = COMPOSITION_CALM
+    else:
+        style = random.choice(MODERN_LANDSCAPES)
+        comp = "balanced composition, no frame, no border"
+    lighting = random.choice([LIGHTING_SOFT, "natural daylight, atmospheric light", "soft studio light"])
+    return f"{style}, {BASE_PAINTING_QUALITY}, {lighting}, {comp}"
+# Device selection
+if torch.backends.mps.is_available():
+    DEVICE = "mps"
+elif torch.cuda.is_available():
+    DEVICE = "cuda"
+else:
+    DEVICE = "cpu"
+if DEVICE == "mps":
+    DTYPE = torch.float32 if USE_FP32_ON_MPS else torch.float16
+elif DEVICE == "cuda":
+    DTYPE = torch.float16
+else:
+    DTYPE = torch.float32
+app = FastAPI()
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+pipe = None
+pipe_lock = threading.Lock()
+q = Queue(maxsize=QUEUE_MAX)
+latest_id = 0
+last_error = ""
+last_gen_ms = None
+generated_total = 0
+last_prompt = ""
+def load_pipeline():
+    global pipe
+    pipe = AutoPipelineForText2Image.from_pretrained(
+        MODEL_ID,
+        torch_dtype=DTYPE,
+        safety_checker=None,
+        feature_extractor=None,
+    ).to(DEVICE)
+    try:
+        pipe.set_progress_bar_config(disable=True)
+    except Exception:
+        pass
+def render_png():
+    global last_prompt
+    prompt = pick_prompt()
+    last_prompt = prompt
+    t0 = time.perf_counter()
+    with pipe_lock, torch.inference_mode():
+        out = pipe(
+            prompt=prompt,
+            negative_prompt=NEGATIVE,
+            width=W,
+            height=H,
+            num_inference_steps=STEPS,
+            guidance_scale=GUIDANCE,
+        )
+    img: Image.Image = out.images[0]
+    buf = io.BytesIO()
+    img.save(buf, format="PNG", optimize=True)
+    ms = (time.perf_counter() - t0) * 1000.0
+    return buf.getvalue(), ms
+def generator_loop():
+    global latest_id, last_error, last_gen_ms, generated_total
+    while True:
+        try:
+            png, ms = render_png()
+            latest_id += 1
+            last_gen_ms = ms
+            last_error = ""
+            generated_total += 1
+            if q.full():
+                try:
+                    q.get_nowait()
+                except Empty:
+                    pass
+            q.put((latest_id, png), timeout=1)
+            if DEVICE == "mps":
+                try:
+                    torch.mps.empty_cache()
+                except Exception:
+                    pass
+        except Exception as e:
+            last_error = repr(e)
+            time.sleep(0.5)
+@app.on_event("startup")
+async def startup():
+    load_pipeline()
+    threading.Thread(target=generator_loop, daemon=True).start()
+@app.get("/", response_class=HTMLResponse)
+def root():
+    try:
+        with open(os.path.join(os.path.dirname(__file__), "index.html"), "r", encoding="utf-8") as f:
+            return f.read()
+    except Exception:
+        return "<html><body style='background:black;color:white;font-family:system-ui'>index.html not found</body></html>"
+@app.get("/health")
+def health():
+    return JSONResponse({
+        "device": DEVICE,
+        "dtype": str(DTYPE),
+        "model": MODEL_ID,
+        "w": W,
+        "h": H,
+        "steps": STEPS,
+        "guidance": GUIDANCE,
+        "queue": q.qsize(),
+        "latest_id": latest_id,
+        "last_gen_ms": last_gen_ms,
+        "last_error": last_error,
+        "generated_total": generated_total,
+        "p_modern": P_MODERN,
+        "p_classic": P_CLASSIC,
+        "p_early": P_EARLY,
+        "classic_people_weight": CLASSIC_PEOPLE_WEIGHT,
+        "modern_people_weight": MODERN_PEOPLE_WEIGHT,
+        "last_prompt": last_prompt[:400],
+    })
+@app.get("/next")
+def next_frame():
+    fid, png = q.get(timeout=600)
+    return Response(
+        content=png,
+        media_type="image/png",
+        headers={"X-Frame-Id": str(fid), "Cache-Control": "no-store"},
+    )