Merge branch 'main' of https://github.com/albertchriss/Algeo02-23054

Author: albertchriss

src/backend/audio/audioprocessing.py

@@ -121,7 +121,7 @@ def preprocess_database(dataset_path):
                 # Use os.path.join(root, file) directly
                 midi_files.append(os.path.join(root, file))
 
-    midi_files = midi_files[:100]
+    midi_files = midi_files
     all_vect_hist = {}
     # Loop melalui semua file MIDI
     for midi_file in midi_files:
@@ -145,6 +145,8 @@ def preprocess_database(dataset_path):
 def process_query(query_path, database):
     try:
         query_data = PrettyMIDI(query_path)
+        progress = 10
+        yield progress
         # Process MIDI data
         query_windows = group_beat_by_window(query_data)
 
@@ -157,19 +159,21 @@ def process_query(query_path, database):
                 hist_rtb = calculate_rtb(window)
                 hist_ftb = calculate_ftb(window)
                 database[query_path].append([hist_atb,hist_rtb,hist_ftb])
+            progress += 20/len(query_windows)
+            yield progress
 
         # compare query to database
-        print(len(database.keys()))
         for midi_file in database.keys():
             if(midi_file == query_path):
                 continue
             similarity_result = sliding_similarity(database[midi_file], database[query_path])
             if(similarity_result >= 0.7000000):
                 final_res.append({
-                    # "score": similarity_result,
                     "score": similarity_result,
                     "filename": midi_file
                 })
+            progress += 70/len(database.keys())
+            yield progress
         final_res.sort(key=lambda x: x["score"], reverse=True)
         return final_res
 

src/backend/image/image_processing.py

@@ -170,20 +170,25 @@ def queryImage(query_paths: list, cache_path: str, target_size=100, batch_size=4
 
     print("Starting image processing...")
     startTime = time.time()
+    yield 10
     #query to matrix---------------------------------------------------------------------------------------------------------------------
     queryPicture = process_images_in_batches(query_paths, target_size, batch_size)
     t1 = time.time()
     print(f"imgQuery to matrix: {t1-startTime}")
+    yield 20
     #centering dataPicture---------------------------------------------------------------------------------------------------------------------
     queryPicture_centered = center_data_with_mean(queryPicture, dataMean)
     t2 = time.time()
     print(f"data centering: {t2-t1}")
+    yield 30
     # Project queryPicture---------------------------------------------------------------------------------------------------------------------
     projected_query = project_data(queryPicture_centered, eigenvectors)
     t3 = time.time()
     print(f"query projection: {t3-t2}")
+    yield 40
 
     sorted_imgPaths = compute_similarity(projected_data, projected_query)
+    yield 60
 
     t4 = time.time()
     print(f"compute similarity: {t4-t3}")
@@ -192,11 +197,13 @@ def queryImage(query_paths: list, cache_path: str, target_size=100, batch_size=4
     )
     t5 = time.time()
     print(f"sortZip: {t5-t4}")
+    yield 80
     sorted_by_percentage_images = []
     for similarity, img_path in sorted_similarities[:12]:
         print(f"Image: {img_path}, Similarity: {similarity:.2f}%")
         if similarity > 75:
             sorted_by_percentage_images.append({"filename": img_path, "score": similarity})
+    yield 100
     return sorted_by_percentage_images
 
 

src/backend/main.py

@@ -66,41 +66,47 @@ async def processing_with_progress():
                     return
 
 
-                yield "data: 10\n\n"
+                yield "data: 0\n\n"
 
                 now = time.time()
                 result = None
 
                 if is_image:
                 # Start image processing and stream progress
-                    result = queryImage([str(extracted_file_path)], DATASET_DIR)
-                    # generator = imageProcessing(DATASET_DIR, [str(extracted_file_path)])
-                    # while True:
-                    #     try:
-                    #         progress = next(generator)  # Get the next progress value
-                    #         yield f"data: {progress}\n\n"
-                    #     except StopIteration as stop_result:
-                    #         # Capture the final result from the generator
-                    #         result = stop_result.value
-                    #         break
+                    # result = queryImage([str(extracted_file_path)], DATASET_DIR)
+                    generator = queryImage([str(extracted_file_path)], DATASET_DIR)
+                    while True:
+                        try:
+                            progress = next(generator)  # Get the next progress value
+
+                            yield f"data: {progress}\n\n"
+                        except StopIteration as stop_result:
+                            # Capture the final result from the generator
+                            result = stop_result.value
+                            break
 
                 else:
                     # Load the preprocessed database if it exists, otherwise preprocess and save it
                     database_path = DATASET_DIR / "preprocessed_database.pkl"
                     if database_path.exists():
                         database = joblib.load(database_path)
+                    generator = process_query(str(extracted_file_path), database)
 
-                    print(len(database))
-                    result = process_query(str(extracted_file_path), database)
-                    print(result[:limit])
-                    # print(result)
+                    while True:
+                        try:
+                            progress = next(generator)  # Get the next progress value
 
+                            yield f"data: {progress}\n\n"
+                        except StopIteration as stop_result:
+                            # Capture the final result from the generator
+                            result = stop_result.value
+                            break
                 time_taken = time.time() - now
                 query_file_path = QUERY_RESULT_DIR / "result.txt"
 
                 with open(query_file_path, "w", encoding="utf-8") as query_file:
                     for res in result[:limit]:
-                        query_file.write(f"{res["filename"]} {res["score"]}\n")
+                        query_file.write(f"{res['filename']} {res['score']}\n")
                     query_file.write(str(time_taken) + "\n")
 
                 yield "data: 100\n\n"
@@ -197,44 +203,48 @@ async def create_upload_dataset(file_upload: UploadFile, is_image: str = Form(..
 
     try:
         zip_data = await file_upload.read()
+        progress = 10
+        async def processing_with_progress():
+            nonlocal progress
+            yield "data: 10\n\n"
+            # extract zip file
+            with zipfile.ZipFile(io.BytesIO(zip_data)) as zip_ref:
+                increment = 70 / len(zip_ref.infolist())
+                for file_info in zip_ref.infolist():
+                    # Skip directories
+                    if file_info.is_dir():
+                        continue
 
-        # extract zip file
-        with zipfile.ZipFile(io.BytesIO(zip_data)) as zip_ref:
-            for file_info in zip_ref.infolist():
-                # Skip directories
-                if file_info.is_dir():
-                    continue
-
-                file_name = file_info.filename
-                # check jika file adalah file gambar atau file audio
-                if (is_image_file(file_name) and is_image) or (is_midi_file(file_name) and not is_image):
-                    extracted_file_path = DATASET_DIR / Path(file_name).name
-                    try:
-                        with open(extracted_file_path, "wb") as extracted_file:
-                            extracted_file.write(zip_ref.read(file_name))
-                    except:
-                        print(f"Failed to write file: {file_name}")
+                    file_name = file_info.filename
+                    # check jika file adalah file gambar atau file audio
+                    if (is_image_file(file_name) and is_image) or (is_midi_file(file_name) and not is_image):
+                        extracted_file_path = DATASET_DIR / Path(file_name).name
+                        try:
+                            with open(extracted_file_path, "wb") as extracted_file:
+                                extracted_file.write(zip_ref.read(file_name))
+                        except:
+                            print(f"Failed to write file: {file_name}")
+                            continue
+                    
+                    # file bukan file gambar atau file audio
+                    else:
                         continue
-                
-                # file bukan file gambar atau file audio
-                else:
-                    continue
+                    progress += increment
+                    yield f"data: {progress}\n\n"
 
-        if (is_image):
-            image_paths, projected_data, eigenvectors, dataMean = preProcessingDataSet(DATASET_DIR)
-            # Save the processed data using joblib
-            path = DATASET_DIR / "processed_data.pkl"
-            joblib.dump((image_paths, projected_data, eigenvectors, dataMean), path)
-        else:
-            database = preprocess_database(DATASET_DIR)
-            path = DATASET_DIR / "preprocessed_database.pkl"
-            joblib.dump(database, path)
-                        
-        data_urls = [
-            f"http://localhost:8000/uploads/dataset/{file_name}"
-            for file_name in os.listdir(DATASET_DIR)
-        ]
-        return {"uploaded_images": data_urls}
+            if (is_image):
+                image_paths, projected_data, eigenvectors, dataMean = preProcessingDataSet(DATASET_DIR)
+                # Save the processed data using joblib
+                path = DATASET_DIR / "processed_data.pkl"
+                joblib.dump((image_paths, projected_data, eigenvectors, dataMean), path)
+            else:
+                database = preprocess_database(DATASET_DIR)
+                path = DATASET_DIR / "preprocessed_database.pkl"
+                joblib.dump(database, path)
+        
+            yield f"data: 100\n\n"
+
+        return StreamingResponse(processing_with_progress(), media_type="text/event-stream")
 
     except zipfile.BadZipFile:
         raise HTTPException(status_code=400, detail="Invalid zip file")

src/frontend/src/components/SongCard.tsx

@@ -1,32 +1,23 @@
-"use client"
-import React, { useState } from "react";
+"use client";
+import React from "react";
 import Image from "next/image";
-import { FaPlay, FaPause } from "react-icons/fa";
 import { useRouter } from "next/navigation";
 
 interface SongCardProps {
   imgSrc: string;
   title: string;
-  duration: string;
   number: number;
+  score?: number;
 }
 
-export const SongCard = ({
-  imgSrc,
-  title,
-  duration,
-  number,
-}: SongCardProps) => {
-  const [isPlaying, setIsPlaying] = useState(false);
-  const handlePlayPause = () => {
-    setIsPlaying(!isPlaying);
-  };
+export const SongCard = ({ imgSrc, title, number, score }: SongCardProps) => {
   const router = useRouter();
 
-
   return (
-    <div className="w-full grid grid-cols-12 py-3 px-6 text-biru-teks bg-white shadow-xl shadow-gray-200/50 hover:scale-105 hover:bg-cyan-tua/10 transition-all duration-300 hover:cursor-pointer"
-    onClick={() => router.push(`/song/${title}.mid`)}>
+    <div
+      className="w-full grid grid-cols-12 py-3 px-6 text-biru-teks bg-white shadow-xl shadow-gray-200/50 hover:scale-105 hover:bg-cyan-tua/10 transition-all duration-300 hover:cursor-pointer"
+      onClick={() => router.push(`/song/${title}.mid`)}
+    >
       <div className="col-span-1 flex items-center">
         <p className="font-extrabold text-xl">{number}</p>
       </div>
@@ -39,21 +30,16 @@ export const SongCard = ({
           className="size-10 object-cover rounded-sm"
         />
       </div>
-      <div className="col-span-8 flex items-center">
+      <div
+        className={`${score ? "col-span-8" : "col-span-10"} flex items-center`}
+      >
         <h3 className="text-md font-bold">{title}</h3>
       </div>
-      <div className="col-span-1 flex items-center justify-end">
-        <p className="text-center text-gray-500">{duration}</p>
-      </div>
-      <div className="col-span-1 flex items-center justify-end">
-        <button onClick={handlePlayPause}>
-          {isPlaying ? (
-            <FaPause className="text-2xl" />
-          ) : (
-            <FaPlay className="text-2xl" />
-          )}
-        </button>
-      </div>
+      {score && (
+        <div className="col-span-2 flex items-center justify-end">
+          <p className="text-center text-gray-500">Similarity: {(score*100).toFixed(2)}%</p>
+        </div>
+      )}
     </div>
   );
 };

src/frontend/src/components/search/AudioResult.tsx

@@ -5,9 +5,13 @@ import { Song } from "../home/PopularSongs";
 import { SongSkeleton } from "../home/SongSkeleton";
 import { SongCard } from "../SongCard";
 
+type extendedSong = Song & {
+  score: string;
+}
+
 export const AudioResult = () => {
   const { toast } = useToast();
-  const [resultAudios, setResultAudios] = useState<Song[]>([]);
+  const [resultAudios, setResultAudios] = useState<extendedSong[]>([]);
   const [timeTaken, setTimeTaken] = useState(0);
   const [isLoading, setIsLoading] = useState(true);
 
@@ -74,7 +78,7 @@ export const AudioResult = () => {
               key={index}
               imgSrc={song.imgSrc}
               title={song.title}
-              duration={"3:00"}
+              score={Number(song.score)}
               number={index + 1}
             />
           ))