import os
import argparse
from fastsam import FastSAM, FastSAMPrompt
import ast
import torch
import numpy as np
import pandas as pd
from PIL import Image
from utils.tools import convert_box_xywh_to_xyxy

def get_config():
    args = argparse.Namespace()
    args.model_path = "./weights/FastSAM-x.pt"
    args.img_path = "./uploads/"
    args.imgsz = 1024
    args.iou = 0.9
    args.text_prompt = "leaf"
    args.conf = 0.4
    args.output = "./output/"
    args.randomcolor = True
    args.point_prompt = "[[0,0]]"
    args.point_label = "[0]"
    args.box_prompt = "[[0,0,0,0]]"
    args.better_quality = False
    args.device = "cuda" if torch.cuda.is_available() else "mps" if torch.backends.mps.is_available() else "cpu"
    args.retina = True
    args.withContours = False
    return args

def process_image(img_path, args):
    model = FastSAM(args.model_path)
    args.point_prompt = ast.literal_eval(args.point_prompt)
    args.box_prompt = convert_box_xywh_to_xyxy(ast.literal_eval(args.box_prompt))
    args.point_label = ast.literal_eval(args.point_label)
    input = Image.open(img_path)
    input = input.convert("RGB")
    everything_results = model(
        input,
        device=args.device,
        retina_masks=args.retina,
        imgsz=args.imgsz,
        conf=args.conf,
        iou=args.iou
    )
    bboxes = None
    points = None
    point_label = None
    prompt_process = FastSAMPrompt(input, everything_results, device=args.device)
    if args.box_prompt[0][2] != 0 and args.box_prompt[0][3] != 0:
        ann = prompt_process.box_prompt(bboxes=args.box_prompt)
        bboxes = args.box_prompt

    elif args.text_prompt != None:
        ann = prompt_process.text_prompt(text=args.text_prompt)
        pixel_count = np.sum(ann)
        leaf_area = pixel_count * 0.000508
        leaf_area = round(leaf_area, 2)
        print("실제 잎의 면적: ", leaf_area, 'cm^2')

    elif args.point_prompt[0] != [0, 0]:
        ann = prompt_process.point_prompt(
            points=args.point_prompt, pointlabel=args.point_label
        )
        points = args.point_prompt
        point_label = args.point_label
    else:
        ann = prompt_process.everything_prompt()

    output_filename = os.path.splitext(os.path.basename(img_path))[0] + '.jpg'
    output_path = os.path.join(args.output, output_filename)

    prompt_process.plot(
        annotations=ann,
        output_path=output_path,
        bboxes=bboxes,
        points=points,
        point_label=point_label,
        withContours=args.withContours,
        better_quality=args.better_quality,
    )

    return leaf_area

def main(args):
    original_point_prompt = args.point_prompt
    original_box_prompt = args.box_prompt
    original_point_label = args.point_label

    results = []
    image_names = [] 
    for img_file in sorted(os.listdir(args.img_path)):
        if img_file.lower().endswith(('.png', '.jpg', '.jpeg')):
            img_path = os.path.join(args.img_path, img_file)
            args.point_prompt = original_point_prompt
            args.box_prompt = original_box_prompt
            args.point_label = original_point_label
            results.append(process_image(img_path, args))
            image_names.append(img_file)

    df = pd.DataFrame({'Filename': image_names, 'Leaf_Area': results})
    df.to_csv('results.csv', index=False)

    print(results)

if __name__ == "__main__":
    args = get_config()
    main(args)

import ast
from fastapi import FastAPI, File, UploadFile, Request
from fastapi.responses import HTMLResponse, FileResponse
from fastapi.templating import Jinja2Templates
from fastapi.staticfiles import StaticFiles
import os
from typing import List
import Inference3
import pandas as pd

app = FastAPI()
templates = Jinja2Templates(directory="templates")
app.mount("/output", StaticFiles(directory="output"), name="output")

log_filename = "history.log"  # 로그 파일 이름
results_data = []

def log_results(results):
    with open(log_filename, "a") as log_file:
        for result in results:
            log_file.write(f"{result}\n")

@app.get("/", response_class=HTMLResponse)
async def upload_form(request: Request):
    return templates.TemplateResponse("upload_form.html", {"request": request})

def save_results_to_csv(results, filename="results.csv"):
    df = pd.DataFrame(results)
    df.to_csv(filename, index=False)

@app.post("/upload/")
async def upload_images(files: List[UploadFile] = File(...)):
    global results_data
    results = []

    for file in files:
        file_location = f"uploads/{file.filename}"
        with open(file_location, "wb+") as file_object:
            file_object.write(await file.read())  # 비동기 파일 읽기

        # Inference3 실행
        args = Inference3.get_config()
        args.img_path = file_location
        leaf_area = Inference3.process_image(file_location, args)

        output_image_path = os.path.join('output', os.path.splitext(file.filename)[0] + '.jpg')
        output_image_url = f'/output/{os.path.basename(output_image_path)}'

        results.append({"filename": file.filename, "leaf_area": leaf_area, "output_image_url": output_image_url})

    save_results_to_csv(results)
    results_data.append(results)
    log_results(results)  # 결과 로깅

    return results

@app.get("/download_csv/")
async def download_csv():
    return FileResponse("results.csv", media_type='application/octet-stream', filename="results.csv")

@app.get("/results/")
async def get_results():
    global results_data
    return results_data

@app.get("/history/", response_class=HTMLResponse)
async def view_history(request: Request):
    with open("history.log", "r") as log_file:
        history_data = [ast.literal_eval(line) for line in log_file.readlines()]
    return templates.TemplateResponse("history_page.html", {"request": request, "history": history_data})

@app.get("/view-results/", response_class=HTMLResponse)
async def view_results(request: Request):
    return templates.TemplateResponse("results_page.html", {"request": request})

# if __name__ == "__main__":
#     import uvicorn
#     uvicorn.run(app="server:app",
#                     host="0.0.0.0",
#                     port=8001,
#                     reload=True)

import serial
import requests
import os
import cv2
from datetime import datetime

url = "http://113.198.63.26:13392/upload/"
ser = serial.Serial('/dev/ttyUSB0', 9600, timeout=1)

capture_counter = 0
def gstreamer_pipeline():
    return (
        "nvarguscamerasrc ! "
        "video/x-raw(memory:NVMM), width=(int)1280, height=(int)1080, format=(string)NV12, framerate=(fraction)30/1 ! "
        "nvvidconv ! video/x-raw, format=(string)BGRx ! "
        "videoconvert ! video/x-raw, format=(string)BGR ! appsink"
    )

def capture_image(filename):
    if not os.path.exists('capture_images'):
        os.makedirs('capture_images')

    full_filename = os.path.join('capture_images', filename)
    cap = cv2.VideoCapture(gstreamer_pipeline(), cv2.CAP_GSTREAMER)
    if cap.isOpened():
        ret, frame = cap.read()
        if ret:
            cv2.imwrite(full_filename, frame)
        cap.release()
    else:
        print("Unable to open the camera")

if __name__=='__main__':
    while True:
        if ser.in_waiting > 0:
            line = ser.readline().decode('utf-8').rstrip()

            if line == "CAPTURE":
                now = datetime.now()
                filename = f"image_{now.strftime('%Y%m%d_%H%M')}_{capture_counter}.jpg"  # 파일명에 카운터 추가
                capture_image(filename)
                capture_counter += 1

            elif line == "SEND":
                image_files = [os.path.join('capture_images', file) for file in os.listdir('capture_images') if file.endswith('.jpg') or file.endswith('.png')]
                files = [('files', (open(file, 'rb'))) for file in image_files]

                response = requests.post(url, files=files)
                print(response.text)

                for file in image_files:
                    os.remove(file)
                break