Upload 12 files

.env

@@ -0,0 +1,3 @@
+FLASK_ENV=development
+SQLALCHEMY_DATABASE_URI=sqlite:///feedback.db
+SECRET_KEY=your-secret-key

Dockerfile

@@ -0,0 +1,16 @@
+FROM python:3.10-slim
+
+WORKDIR /app
+
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+COPY . .
+
+ENV FLASK_APP=app.py
+ENV FLASK_RUN_HOST=0.0.0.0
+ENV FLASK_RUN_PORT=7860  # Hugging Face Spaces default port
+
+EXPOSE 7860
+
+CMD ["flask", "run"]

README.md

@@ -1,10 +0,0 @@
----
-title: Piecefinder
-emoji: 👁
-colorFrom: yellow
-colorTo: red
-sdk: docker
-pinned: false
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

app.py

@@ -0,0 +1,6 @@
+from app import create_app
+
+app = create_app()
+
+if __name__ == '__main__':
+    app.run()

app/__init__.py

@@ -0,0 +1,20 @@
+from flask import Flask
+from flask_sqlalchemy import SQLAlchemy
+
+db = SQLAlchemy()
+
+def create_app():
+    app = Flask(__name__)
+    app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///feedback.db'
+    app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False
+    app.config['SECRET_KEY'] = 'your-secret-key'  # Replace with env variable in production
+
+    db.init_app(app)
+
+    with app.app_context():
+        db.create_all()  # Create database tables
+
+    from app.routes import bp
+    app.register_blueprint(bp)
+
+    return app

app/feedback.py

@@ -0,0 +1,23 @@
+from app import db
+from flask_sqlalchemy import SQLAlchemy
+import json
+
+class Feedback(db.Model):
+    id = db.Column(db.Integer, primary_key=True)
+    piece_id = db.Column(db.Integer, nullable=False)
+    slot_id = db.Column(db.Integer, nullable=False)
+    suggestions = db.Column(db.Text, nullable=False)
+    user_choice = db.Column(db.Integer, nullable=False)
+    is_correct = db.Column(db.Boolean, nullable=False)
+
+class FeedbackManager:
+    def record_feedback(self, piece_id: int, slot_id: int, suggestions: dict, user_choice: int, is_correct: bool):
+        feedback = Feedback(
+            piece_id=piece_id,
+            slot_id=slot_id,
+            suggestions=json.dumps(suggestions),
+            user_choice=user_choice,
+            is_correct=is_correct
+        )
+        db.session.add(feedback)
+        db.session.commit()

app/matcher.py

@@ -0,0 +1,20 @@
+import cv2
+import numpy as np
+
+class SimpleMatcher:
+    def find_matches(self, pieces: list, slots: list, top_k: int = 3) -> list:
+        matches = []
+        for slot in slots:
+            slot_hist = slot['features']['color']
+            slot_matches = []
+            for piece in pieces:
+                piece_hist = piece['features']['color']
+                confidence = cv2.compareHist(piece_hist, slot_hist, cv2.HISTCMP_CORREL)
+                slot_matches.append({
+                    'piece_id': piece['id'],
+                    'slot_id': slot['id'],
+                    'confidence': float(confidence)
+                })
+            slot_matches.sort(key=lambda x: x['confidence'], reverse=True)
+            matches.extend(slot_matches[:top_k])
+        return matches

app/routes.py

@@ -0,0 +1,112 @@
+from flask import Blueprint, request, jsonify
+from app.segmenter import SimpleSegmenter
+from app.matcher import SimpleMatcher
+from app.feedback import FeedbackManager
+import base64
+import cv2
+import numpy as np
+
+bp = Blueprint('api', __name__)
+
+@bp.route('/segment', methods=['POST'])
+def segment_image():
+    try:
+        data = request.get_json()
+        image_base64 = data.get('image_base64')
+        if not image_base64:
+            return jsonify({'error': 'No image provided'}), 400
+
+        # Decode base64 image
+        image_data = base64.b64decode(image_base64)
+        nparr = np.frombuffer(image_data, np.uint8)
+        image = cv2.imdecode(nparr, cv2.IMREAD_COLOR)
+
+        # Segment pieces
+        segmenter = SimpleSegmenter()
+        pieces = segmenter.segment_pieces(image)
+
+        # Serialize pieces
+        serialized_pieces = [
+            {
+                'id': piece['id'],
+                'image': base64.b64encode(piece['image']).decode('utf-8'),
+                'features': piece['features']
+            }
+            for piece in pieces
+        ]
+
+        return jsonify({'pieces': serialized_pieces}), 200
+    except Exception as e:
+        return jsonify({'error': str(e)}), 500
+
+@bp.route('/count', methods=['POST'])
+def count_pieces():
+    try:
+        data = request.get_json()
+        image_base64 = data.get('image_base64')
+        if not image_base64:
+            return jsonify({'error': 'No image provided'}), 400
+
+        image_data = base64.b64decode(image_base64)
+        nparr = np.frombuffer(image_data, np.uint8)
+        image = cv2.imdecode(nparr, cv2.IMREAD_COLOR)
+
+        segmenter = SimpleSegmenter()
+        pieces = segmenter.segment_pieces(image)
+        count = len(pieces)
+
+        return jsonify({'count': count}), 200
+    except Exception as e:
+        return jsonify({'error': str(e)}), 500
+
+@bp.route('/match', methods=['POST'])
+def match_pieces():
+    try:
+        data = request.get_json()
+        image_base64 = data.get('image_base64')
+        if not image_base64:
+            return jsonify({'error': 'No image provided'}), 400
+
+        image_data = base64.b64decode(image_base64)
+        nparr = np.frombuffer(image_data, np.uint8)
+        image = cv2.imdecode(nparr, cv2.IMREAD_COLOR)
+
+        segmenter = SimpleSegmenter()
+        matcher = SimpleMatcher()
+        pieces = segmenter.segment_pieces(image)
+        slots = pieces  # Simplified: assume slots are same as pieces
+
+        matches = matcher.find_matches(pieces, slots)
+
+        serialized_matches = [
+            {
+                'piece_id': match['piece_id'],
+                'slot_id': match['slot_id'],
+                'confidence': match['confidence']
+            }
+            for match in matches
+        ]
+
+        return jsonify({'matches': serialized_matches, 'slots': [{'id': slot['id']} for slot in slots]}), 200
+    except Exception as e:
+        return jsonify({'error': str(e)}), 500
+
+@bp.route('/feedback', methods=['POST'])
+def submit_feedback():
+    try:
+        data = request.get_json()
+        piece_id = data.get('pieceId')
+        slot_id = data.get('slotId')
+        suggestions = data.get('suggestions')
+        user_choice = data.get('userChoice')
+        is_correct = data.get('isCorrect')
+
+        if not all([piece_id, slot_id, suggestions, user_choice is not None, is_correct is not None]):
+            return jsonify({'error': 'Missing required fields'}), 400
+
+        feedback_manager = FeedbackManager()
+        feedback_manager.record_feedback(piece_id, slot_id, suggestions, user_choice, is_correct)
+
+        return jsonify({'message': 'Feedback recorded successfully'}), 200
+    except Exception as e:
+        return jsonify({'error': str(e)}), 500

app/segmenter.py

@@ -0,0 +1,35 @@
+import cv2
+import numpy as np
+from app.utils import preprocess_image, extract_features
+
+class SimpleSegmenter:
+    def __init__(self):
+        self.min_piece_area = 500
+        self.max_piece_area = 50000
+
+    def segment_pieces(self, image: np.ndarray) -> list:
+        # Preprocess image
+        processed = preprocess_image(image)
+        gray = cv2.cvtColor(processed, cv2.COLOR_BGR2GRAY)
+        _, thresh = cv2.threshold(gray, 240, 255, cv2.THRESH_BINARY_INV)
+
+        # Find contours
+        contours, _ = cv2.findContours(thresh, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
+        pieces = []
+        piece_id = 0
+
+        for contour in contours:
+            area = cv2.contourArea(contour)
+            if self.min_piece_area <= area <= self.max_piece_area:
+                mask = np.zeros(image.shape[:2], dtype=np.uint8)
+                cv2.drawContours(mask, [contour], -1, 255, -1)
+                piece_image = cv2.bitwise_and(image, image, mask=mask)
+                features = extract_features(piece_image, mask)
+                pieces.append({
+                    'id': piece_id,
+                    'image': cv2.imencode('.jpg', piece_image)[1].tobytes(),
+                    'features': features
+                })
+                piece_id += 1
+
+        return pieces

app/utils.py

@@ -0,0 +1,15 @@
+import cv2
+import numpy as np
+
+def preprocess_image(image: np.ndarray) -> np.ndarray:
+    # Simple preprocessing: enhance contrast
+    lab = cv2.cvtColor(image, cv2.COLOR_BGR2LAB)
+    clahe = cv2.createCLAHE(clipLimit=2.0, tileGridSize=(8, 8))
+    lab[:, :, 0] = clahe.apply(lab[:, :, 0])
+    return cv2.cvtColor(lab, cv2.COLOR_LAB2BGR)
+
+def extract_features(image: np.ndarray, mask: np.ndarray) -> dict:
+    # Extract color histogram
+    color_histogram = cv2.calcHist([image], [0, 1, 2], mask, [8, 8, 8], [0, 256, 0, 256, 0, 256])
+    color_histogram = cv2.normalize(color_histogram, color_histogram).flatten()
+    return {'color': color_histogram}

main.py

@@ -0,0 +1,6 @@
+from app import create_app
+
+app = create_app()
+
+if __name__ == '__main__':
+    app.run(debug=True, host='0.0.0.0', port=5000)

requirements.txt

@@ -0,0 +1,4 @@
+flask
+opencv-python
+numpy
+flask-sqlalchemy