Update app.py

app.py

@@ -34,31 +34,44 @@ def get_font_for_height(target_px):
 def make_base_image(w, h):
     img = Image.new("RGB", (w, h), BG_COLOR)
     draw = ImageDraw.Draw(img)
-    target_h = int(min(w, h) * 2.0)
-    target_h = min(target_h, min(w, h) - 4)
+
+    # MASSIVE "CC" (~5x bigger visual dominance)
+    target_h = int(min(w, h) * 0.95)
+
     font = get_font_for_height(target_h)
+
     bbox = draw.textbbox((0, 0), "CC", font=font)
     tw = bbox[2] - bbox[0]
     th = bbox[3] - bbox[1]
+
     x = (w - tw) // 2 - bbox[0]
     y = (h - th) // 2 - bbox[1]
+
     draw.text((x, y), "CC", fill=TEXT_COLOR, font=font)
+
     return img
 
 def calc_size(payload_bytes):
     total_bits = (len(payload_bytes) + 4) * 8
+
+    # Each pixel = 6 bits (2 bits * RGB)
     pixels_needed = math.ceil(total_bits / 6)
-    side = max(MIN_SIZE, math.ceil(math.sqrt(pixels_needed * 4.5)))
+
+    # Increased multiplier due to large CC blocking space
+    side = max(MIN_SIZE, math.ceil(math.sqrt(pixels_needed * 10)))
+
     return side, side
 
 def get_carriers(w, h):
     base = make_base_image(w, h)
     pixels = base.load()
     carriers = []
+
     for y in range(h):
         for x in range(w):
             if pixels[x, y] == BG_COLOR:
                 carriers.append((x, y))
+
     return carriers, base
 
 def bits_from_bytes(data):
@@ -82,24 +95,33 @@ def bytes_from_bits(bits):
 
 def embed(payload):
     w, h = calc_size(payload)
+
     for _ in range(10):
         carriers, img = get_carriers(w, h)
+
         header = struct.pack(">I", len(payload))
         data = header + payload
         bits = bits_from_bytes(data)
+
         if len(bits) <= len(carriers) * BITS_PER_CHANNEL * 3:
             break
-        w = math.ceil(w * 1.2)
-        h = math.ceil(h * 1.2)
+
+        # Grow faster because fewer carriers now
+        w = math.ceil(w * 1.3)
+        h = math.ceil(h * 1.3)
     else:
         raise ValueError("Data too large even after resizing.")
+
     pixels = img.load()
     bit_idx = 0
+
     for (x, y) in carriers:
         if bit_idx >= len(bits):
             break
+
         r, g, b = pixels[x, y]
         new_channels = []
+
         for c in [r, g, b]:
             chunk = 0
             for _ in range(BITS_PER_CHANNEL):
@@ -107,25 +129,33 @@ def embed(payload):
                     chunk = (chunk << 1) | bits[bit_idx]
                     bit_idx += 1
                 else:
-                    chunk = chunk << 1
+                    chunk <<= 1
             new_channels.append((c & ~MASK) | chunk)
+
         pixels[x, y] = tuple(new_channels)
+
     return img
 
 def extract(img):
     w, h = img.size
     carriers, _ = get_carriers(w, h)
+
     pixels = img.load()
     bits = []
+
     for (x, y) in carriers:
         r, g, b = pixels[x, y]
         for c in [r, g, b]:
             for i in range(BITS_PER_CHANNEL - 1, -1, -1):
                 bits.append((c >> i) & 1)
+
     length = struct.unpack(">I", bytes_from_bits(bits[:32]))[0]
+
     if length == 0 or length > MAX_BYTES + 10:
         return None, None
+
     payload = bytes_from_bits(bits[32:32 + length * 8])
+
     return length, payload
 
 @app.route("/")
@@ -136,17 +166,23 @@ def index():
 def encode_text():
     data = request.json
     text = data.get("text", "")
+
     if not text:
         return jsonify({"error": "No text provided"}), 400
+
     payload = b'\x00' + text.encode("utf-8")
+
     if len(payload) > MAX_BYTES:
         return jsonify({"error": "Text too large. Max 5MB."}), 400
+
     try:
         img = embed(payload)
         buf = io.BytesIO()
         img.save(buf, format="PNG")
+
         img_b64 = base64.b64encode(buf.getvalue()).decode()
         w, h = img.size
+
         return jsonify({"image": img_b64, "size": f"{w}×{h}"})
     except Exception as e:
         return jsonify({"error": str(e)}), 500
@@ -155,19 +191,27 @@ def encode_text():
 def encode_file():
     if "file" not in request.files:
         return jsonify({"error": "No file uploaded"}), 400
+
     f = request.files["file"]
     raw = f.read()
+
     if len(raw) > MAX_BYTES:
-        return jsonify({"error": f"File too large: {len(raw)/1024/1024:.2f}MB. Max is 5MB."}), 400
+        return jsonify({
+            "error": f"File too large: {len(raw)/1024/1024:.2f}MB. Max is 5MB."
+        }), 400
+
     fname = f.filename or ""
     mode = b'\x02' if fname.lower().endswith(".pdf") else b'\x01'
     payload = mode + raw
+
     try:
         img = embed(payload)
         buf = io.BytesIO()
         img.save(buf, format="PNG")
+
         img_b64 = base64.b64encode(buf.getvalue()).decode()
         w, h = img.size
+
         return jsonify({"image": img_b64, "size": f"{w}×{h}"})
     except Exception as e:
         return jsonify({"error": str(e)}), 500
@@ -176,19 +220,36 @@ def encode_file():
 def decode_route():
     if "file" not in request.files:
         return jsonify({"error": "No file uploaded"}), 400
+
     f = request.files["file"]
     img = Image.open(f).convert("RGB")
+
     length, payload = extract(img)
+
     if payload is None:
         return jsonify({"error": "Nothing encoded or invalid image"}), 400
+
     mode = payload[0]
     content = payload[1:]
+
     if mode == 0:
-        return jsonify({"type": "text", "text": content.decode("utf-8", errors="replace")})
+        return jsonify({
+            "type": "text",
+            "text": content.decode("utf-8", errors="replace")
+        })
+
     elif mode == 1:
-        return jsonify({"type": "image", "image": base64.b64encode(content).decode()})
+        return jsonify({
+            "type": "image",
+            "image": base64.b64encode(content).decode()
+        })
+
     elif mode == 2:
-        return jsonify({"type": "pdf", "pdf": base64.b64encode(content).decode()})
+        return jsonify({
+            "type": "pdf",
+            "pdf": base64.b64encode(content).decode()
+        })
+
     return jsonify({"error": "Unknown mode"}), 400
 
 if __name__ == "__main__":