Datasets:

luzasd
/

foren

+from flask import Flask, request, send_from_directory, jsonify, render_template
+from werkzeug.utils import secure_filename
+import os
+import cv2
+from utils import apply_watermark, apply_watermark_to_video
+app = Flask(__name__)
+app.config['UPLOAD_FOLDER'] = 'uploads'
+app.config['RESULT_FOLDER'] = 'results'
+@app.route('/')
+def index():
+    return render_template('index.html')
+@app.route('/upload', methods=['POST'])
+def upload_file():
+    video_file = request.files.get('video')
+    image_file = request.files.get('image')
+    text = request.form['text']
+    watermark_image = request.files.get('watermark_image')
+    use_image = False
+    if video_file:
+        filename = secure_filename(video_file.filename)
+        input_path = os.path.join(app.config['UPLOAD_FOLDER'], filename)
+        video_file.save(input_path)
+        watermark_image_path = text
+        if watermark_image:
+            watermark_filename = secure_filename(watermark_image.filename)
+            watermark_image_path = os.path.join(app.config['UPLOAD_FOLDER'], watermark_filename)
+            watermark_image.save(watermark_image_path)
+            use_image = True
+        watermarked_filename = 'watermarked_' + filename
+        watermarked_path = os.path.join(app.config['RESULT_FOLDER'], watermarked_filename)
+        apply_watermark_to_video(input_path, watermarked_path, watermark_image_path, frame_skip=2, use_image=use_image)
+        return jsonify({
+            'original_url': filename,
+            'watermarked_url': watermarked_filename
+        })
+    elif image_file and text:
+        filename = secure_filename(image_file.filename)
+        input_path = os.path.join(app.config['UPLOAD_FOLDER'], filename)
+        image_file.save(input_path)
+        img = cv2.imread(input_path)
+        watermarked_img = apply_watermark(img, text)
+        watermarked_filename = 'watermarked_' + filename
+        watermarked_path = os.path.join(app.config['RESULT_FOLDER'], watermarked_filename)
+        cv2.imwrite(watermarked_path, watermarked_img)
+        return jsonify({
+            'original_url': filename,
+            'watermarked_url': watermarked_filename
+        })
+    return 'Invalid request', 400
+@app.route('/uploads/<filename>')
+def uploaded_file(filename):
+    return send_from_directory(app.config['UPLOAD_FOLDER'], filename)
+@app.route('/results/<filename>')
+def result_file(filename):
+    return send_from_directory(app.config['RESULT_FOLDER'], filename)
+if __name__ == '__main__':
+    if not os.path.exists(app.config['UPLOAD_FOLDER']):
+        os.makedirs(app.config['UPLOAD_FOLDER'])
+    if not os.path.exists(app.config['RESULT_FOLDER']):
+        os.makedirs(app.config['RESULT_FOLDER'])
+    app.run(host='0.0.0.0', port=5000)

foren/render.yaml ADDED Viewed

	@@ -0,0 +1,7 @@

+services:
+  - type: web
+    name: flask-backend
+    env: python
+    plan: free
+    buildCommand: pip install -r requirements.txt
+    startCommand: python app.py

foren/requirements.txt ADDED Viewed

	@@ -0,0 +1,4 @@

+Flask
+numpy
+opencv-python-headless
+werkzeug

foren/static/styles.css ADDED Viewed

	@@ -0,0 +1,31 @@

+body {
+    font-family: Arial, sans-serif;
+    margin: 20px;
+}
+h1 {
+    text-align: center;
+}
+form {
+    display: flex;
+    flex-direction: column;
+    align-items: center;
+    margin-bottom: 20px;
+}
+form div {
+    margin: 10px 0;
+}
+button {
+    padding: 10px 20px;
+    font-size: 16px;
+}
+img, video {
+    margin: 10px 0;
+    border: 1px solid #ccc;
+    padding: 5px;
+    background-color: #f9f9f9;
+}

foren/templates/index.html ADDED Viewed

	@@ -0,0 +1,306 @@

+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Watermark Application</title>
+    <style>
+        body {
+            font-family: Arial, sans-serif;
+            background-color: #333;
+            margin: 0;
+            padding: 0;
+            display: flex;
+            flex-direction: column;
+            align-items: center;
+            justify-content: center;
+            min-height: 100vh;
+            color: #ccc;
+        }
+        nav {
+            margin-bottom: 20px;
+        }
+        nav a {
+            color: #ccc;
+            text-decoration: none;
+            margin: 0 10px;
+        }
+        h1 {
+            margin-bottom: 20px;
+            color: #fff;
+        }
+        .container {
+            display: flex;
+            justify-content: center;
+            width: 80%;
+            flex-direction: column;
+            align-items: center;
+        }
+        .upload-area {
+            border: 2px dashed #009688;
+            padding: 20px;
+            width: 100%;
+            max-width: 500px;
+            text-align: center;
+            background-color: #444;
+            margin-bottom: 20px;
+            cursor: pointer;
+            color: #ccc;
+        }
+        .upload-area:hover {
+            background-color: #555;
+        }
+        form {
+            display: flex;
+            flex-direction: column;
+            align-items: center;
+            width: 100%;
+        }
+        input[type="file"], input[type="text"], input[type="submit"] {
+            margin-bottom: 10px;
+            padding: 10px;
+            width: 80%;
+            max-width: 300px;
+            background-color: #555;
+            color: #ccc;
+            border: 1px solid #666;
+        }
+        input[type="submit"] {
+            background-color: #009688;
+            color: white;
+            border: none;
+            cursor: pointer;
+        }
+        input[type="submit"]:hover {
+            background-color: #00796b;
+        }
+        .result-section {
+            margin: 20px 0;
+            padding-top: 20px;
+            border-top: 1px solid #444;
+        }
+        .result-section video, .result-section img {
+            max-width: 80%;
+            height: auto;
+            display: block;
+            margin: 10px auto;
+        }
+        footer {
+            text-align: center;
+            margin-top: 20px;
+        }
+        footer a {
+            color: #009688;
+            text-decoration: none;
+            font-size: 18px;
+        }
+        footer a:hover {
+            text-decoration: underline;
+        }
+    </style>
+    <script>
+        function switchLanguage(lang) {
+            document.documentElement.lang = lang;
+            if(lang === 'ko') {
+                document.getElementById('title').innerText = '워터마킹 애플리케이션';
+                document.getElementById('uploadVideoLabel').innerText = '비디오 업로드';
+                document.getElementById('uploadImageLabel').innerText = '이미지 업로드';
+                document.getElementById('watermarkTextPlaceholder').placeholder = '워터마크 텍스트';
+                document.getElementById('submit').value = '업로드';
+                document.getElementById('dragDropTextVideo').innerText = '여기에 비디오 파일을 드롭하세요';
+                document.getElementById('dragDropTextImage').innerText = '여기에 이미지 파일을 드롭하세요';
+            } else {
+                document.getElementById('title').innerText = 'Watermark Application';
+                document.getElementById('uploadVideoLabel').innerText = 'Upload Video';
+                document.getElementById('uploadImageLabel').innerText = 'Upload Image';
+                document.getElementById('watermarkTextPlaceholder').placeholder = 'Watermark Text';
+                document.getElementById('submit').value = 'Upload';
+                document.getElementById('dragDropTextVideo').innerText = 'Drag & Drop your video here';
+                document.getElementById('dragDropTextImage').innerText = 'Drag & Drop your image here';
+            }
+        }
+        document.addEventListener('DOMContentLoaded', function() {
+            var videoDropArea = document.getElementById('video-drop-area');
+            var imageDropArea = document.getElementById('image-drop-area');
+            function preventDefaults(e) {
+                e.preventDefault();
+                e.stopPropagation();
+            }
+            ['dragenter', 'dragover', 'dragleave', 'drop'].forEach(eventName => {
+                videoDropArea.addEventListener(eventName, preventDefaults, false);
+                imageDropArea.addEventListener(eventName, preventDefaults, false);
+            });
+            videoDropArea.addEventListener('click', () => document.getElementById('video_file').click());
+            imageDropArea.addEventListener('click', () => document.getElementById('image_file').click());
+            document.getElementById('video_file').addEventListener('change', function(e) {
+                var file = this.files[0];
+                updatePreview(file, 'video-preview', 'video-drop-area');
+            });
+            document.getElementById('image_file').addEventListener('change', function(e) {
+                var file = this.files[0];
+                updatePreview(file, 'image-preview', 'image-drop-area');
+            });
+            function updatePreview(file, previewId, dropAreaId) {
+                var preview = document.getElementById(previewId);
+                var dropArea = document.getElementById(dropAreaId);
+                if (preview) {
+                    preview.remove();
+                }
+                if (file.type.startsWith('video/')) {
+                    var video = document.createElement('video');
+                    video.id = previewId;
+                    video.src = URL.createObjectURL(file);
+                    video.controls = true;
+                    video.style.maxWidth = '100%';
+                    video.style.height = 'auto';
+                    dropArea.appendChild(video);
+                } else if (file.type.startsWith('image/')) {
+                    var img = document.createElement('img');
+                    img.id = previewId;
+                    img.src = URL.createObjectURL(file);
+                    img.style.maxWidth = '100%';
+                    img.style.height = 'auto';
+                    dropArea.appendChild(img);
+                }
+            }
+            document.querySelector('form').addEventListener('submit', function(event) {
+                event.preventDefault();
+                var formData = new FormData(this);
+                fetch('/upload', {
+                    method: 'POST',
+                    body: formData
+                })
+                .then(response => response.json())
+                .then(data => {
+                    displayResults(data);
+                })
+                .catch(error => {
+                    console.error('Error:', error);
+                });
+            });
+            function displayResults(data) {
+                var resultSection = document.getElementById('result');
+                resultSection.innerHTML = '';
+                if (data.original_url) {
+                    var originalHeading = document.createElement('h2');
+                    originalHeading.textContent = 'Original File';
+                    resultSection.appendChild(originalHeading);
+                    if (data.original_url.endsWith('png') || data.original_url.endsWith('jpg') || data.original_url.endsWith('jpeg')) {
+                        var originalImg = document.createElement('img');
+                        originalImg.src = `/uploads/${data.original_url}`;
+                        originalImg.alt = 'Original Image';
+                        resultSection.appendChild(originalImg);
+                    } else {
+                        var originalVideo = document.createElement('video');
+                        originalVideo.src = `/uploads/${data.original_url}`;
+                        originalVideo.controls = true;
+                        resultSection.appendChild(originalVideo);
+                    }
+                    var originalLink = document.createElement('a');
+                    originalLink.href = `/uploads/${data.original_url}`;
+                    originalLink.textContent = 'Download Original';
+                    originalLink.download = true;
+                    resultSection.appendChild(originalLink);
+                }
+                if (data.watermarked_url) {
+                    var watermarkedHeading = document.createElement('h2');
+                    watermarkedHeading.textContent = 'Watermarked File';
+                    resultSection.appendChild(watermarkedHeading);
+                    if (data.watermarked_url.endsWith('png') || data.watermarked_url.endsWith('jpg') || data.watermarked_url.endsWith('jpeg')) {
+                        var watermarkedImg = document.createElement('img');
+                        watermarkedImg.src = `/results/${data.watermarked_url}`;
+                        watermarkedImg.alt = 'Watermarked Image';
+                        resultSection.appendChild(watermarkedImg);
+                    } else {
+                        var watermarkedVideo = document.createElement('video');
+                        watermarkedVideo.src = `/results/${data.watermarked_url}`;
+                        watermarkedVideo.controls = true;
+                        resultSection.appendChild(watermarkedVideo);
+                    }
+                    var watermarkedLink = document.createElement('a');
+                    watermarkedLink.href = `/results/${data.watermarked_url}`;
+                    watermarkedLink.textContent = 'Download Watermarked';
+                    watermarkedLink.download = true;
+                    resultSection.appendChild(watermarkedLink);
+                }
+                if (data.extracted_url) {
+                    var extractedHeading = document.createElement('h2');
+                    extractedHeading.textContent = 'Extracted Watermark';
+                    resultSection.appendChild(extractedHeading);
+                    if (data.extracted_url.endsWith('png') || data.extracted_url.endsWith('jpg') || data.extracted_url.endsWith('jpeg')) {
+                        var extractedImg = document.createElement('img');
+                        extractedImg.src = `/extracts/${data.extracted_url}`;
+                        extractedImg.alt = 'Extracted Watermark Image';
+                        resultSection.appendChild(extractedImg);
+                    } else {
+                        var extractedVideo = document.createElement('video');
+                        extractedVideo.src = `/extracts/${data.extracted_url}`;
+                        extractedVideo.controls = true;
+                        resultSection.appendChild(extractedVideo);
+                    }
+                    var extractedLink = document.createElement('a');
+                    extractedLink.href = `/extracts/${data.extracted_url}`;
+                    extractedLink.textContent = 'Download Extracted';
+                    extractedLink.download = true;
+                    resultSection.appendChild(extractedLink);
+                }
+            }
+        });
+    </script>
+</head>
+<body>
+    <nav>
+        <a href="#" onclick="switchLanguage('en')">English</a> | <a href="#" onclick="switchLanguage('ko')">한국어</a>
+    </nav>
+    <h1 id="title">Watermark Application</h1>
+    <div class="container">
+        <div id="video-drop-area" class="upload-area">
+            <p id="dragDropTextVideo">Drag & Drop your video here</p>
+            <p>or</p>
+            <p>Click to select a file</p>
+        </div>
+        <div id="image-drop-area" class="upload-area">
+            <p id="dragDropTextImage">Drag & Drop your image here</p>
+            <p>or</p>
+            <p>Click to select a file</p>
+        </div>
+    </div>
+    <div class="container">
+        <form action="/upload" method="post" enctype="multipart/form-data">
+            <input type="file" id="video_file" name="video" accept="video/*" style="display: none;">
+            <input type="file" id="image_file" name="image" accept="image/*" style="display: none;">
+            <input type="text" id="watermarkTextPlaceholder" name="text" placeholder="Watermark Text">
+            <input type="file" id="watermark_image" name="watermark_image" accept="image/*" style="display: none;">
+            <label for="watermark_image" id="uploadWatermarkImageLabel" style="cursor: pointer;">Upload Watermark Image</label>
+            <input type="submit" id="submit" value="Upload">
+        </form>
+    </div>
+    <section class="result-section" id="result"></section>
+    <footer>
+        <a href="{{ url_for('index') }}">Go to Main Page</a>
+    </footer>
+</body>
+</html>

foren/templates/netlify.toml ADDED Viewed

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

+[build]
+  publish = "frontend"
+  command = "echo 'Skipping build step'"
+[[redirects]]
+  from = "/*"
+  to = "/index.html"
+  status = 200

foren/utils.py ADDED Viewed

	@@ -0,0 +1,83 @@

+import numpy as np
+import cv2
+import random
+from concurrent.futures import ThreadPoolExecutor
+import os
+# 공통 유틸리티 함수
+def resize_image(img, shape):
+    return cv2.resize(img, (shape[1], shape[0]), interpolation=cv2.INTER_LINEAR)
+def text_to_image(text, img_shape, font=cv2.FONT_HERSHEY_SIMPLEX, font_scale=3, thickness=5):
+    text_size = cv2.getTextSize(text, font, font_scale, thickness)[0]
+    text_x = (img_shape[1] - text_size[0]) // 2
+    text_y = (img_shape[0] + text_size[1]) // 2
+    img_wm = np.zeros(img_shape, dtype=np.uint8)
+    cv2.putText(img_wm, text, (text_x, text_y), font, font_scale, (255, 255, 255), thickness)
+    return img_wm
+# 이미지 워터마크 함수
+def apply_watermark(img, text_or_image_path, alpha=5, use_image=False):
+    height, width = img.shape[:2]
+    if use_image and os.path.exists(text_or_image_path):
+        img_wm = cv2.imread(text_or_image_path, cv2.IMREAD_GRAYSCALE)
+        img_wm = resize_image(img_wm, (height, width))
+    else:
+        img_wm = text_to_image(text_or_image_path, (height, width))
+    img_f = np.fft.fft2(img)
+    y_random_indices, x_random_indices = list(range(height)), list(range(width))
+    random.seed(2021)
+    random.shuffle(x_random_indices)
+    random.shuffle(y_random_indices)
+    random_wm = np.zeros(img.shape, dtype=np.uint8)
+    for y in range(height):
+        for x in range(width):
+            random_wm[y_random_indices[y], x_random_indices[x]] = img_wm[y, x]
+    result_f = img_f + alpha * random_wm
+    result = np.fft.ifft2(result_f)
+    result = np.real(result)
+    result = result.astype(np.uint8)
+    return result
+# 비디오 워터마크 함수
+def process_video(input_path, output_path, process_function, *args, frame_skip=1):
+    try:
+        cap = cv2.VideoCapture(input_path)
+        fourcc = cv2.VideoWriter_fourcc(*'XVID')
+        fps = cap.get(cv2.CAP_PROP_FPS)
+        width = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
+        height = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
+        out = cv2.VideoWriter(output_path, fourcc, fps, (width, height))
+        frame_idx = 0
+        with ThreadPoolExecutor() as executor:
+            futures = []
+            while cap.isOpened():
+                ret, frame = cap.read()
+                if not ret:
+                    break
+                if frame_idx % frame_skip == 0:
+                    futures.append(executor.submit(process_function, frame, *args))
+                frame_idx += 1
+            for future in futures:
+                processed_frame = future.result()
+                out.write(processed_frame)
+        cap.release()
+        out.release()
+    except Exception as e:
+        print(f"Error processing video: {e}")
+def apply_watermark_to_video(input_path, output_path, text_or_image_path, frame_skip=1, use_image=False):
+    process_video(input_path, output_path, apply_watermark, text_or_image_path, frame_skip, use_image)