NoteKit

import base64
import os
from dotenv import load_dotenv
from openai import OpenAI
import cv2
import PIL.Image as PILImage
from io import BytesIO
import numpy as np

load_dotenv()

api_key = os.getenv("GEMINI_API_KEY")

print(f"API Key: {api_key}")

client = OpenAI(
    api_key=api_key,
    base_url="https://generativelanguage.googleapis.com/v1beta/openai/"
)

# Function to encode the image
# def encode_image(image_path):
#   with open(image_path, "rb") as image_file:
#     return base64.b64encode(image_file.read()).decode('utf-8')
  
def preprocess_image(image_path):
    img = cv2.imread(image_path)
    pil_image = PILImage.fromarray(img)
    buffered = BytesIO()
    pil_image.save(buffered, format="JPEG")

    norm_img = np.zeros((img.shape[0], img.shape[1]))
    img = cv2.normalize(img, norm_img, 0, 255, cv2.NORM_MINMAX)

    #convert to grayscale
    img = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
    #denoise
    img = cv2.fastNlMeansDenoising(img, None, 10, 7, 21)


    img = cv2.bitwise_not(img)

    # threshold the image, setting all foreground pixels to
# 255 and all background pixels to 0
    img = cv2.threshold(img, 0, 255,
	  cv2.THRESH_BINARY | cv2.THRESH_OTSU)[1]

    # grab the (x, y) coordinates of all pixel values that
    # are greater than zero, then use these coordinates to
    # compute a rotated bounding box that contains all
    # coordinates
    # coords = np.column_stack(np.where(img > 0))
    # angle = cv2.minAreaRect(coords)[-1]
    
    # # the `cv2.minAreaRect` function returns values in the
    # # range [-90, 0); as the rectangle rotates clockwise the
    # # returned angle trends to 0 -- in this special case we
    # # need to add 90 degrees to the angle
    # if angle < -45:
    #     angle = -(90 + angle)
    # # otherwise, just take the inverse of the angle to make
    # # it positive
    # else:
    #     angle = -angle
    
    # print("angle",angle)

    # (h, w) = img.shape[:2]
    # center = (w // 2, h // 2)
    # M = cv2.getRotationMatrix2D(center, angle, 1.0)
    # img = cv2.warpAffine(img, M, (w, h), flags=cv2.INTER_CUBIC,borderMode=cv2.BORDER_REPLICATE)

    

    # cv2.imshow("norm",img)
    # cv2.waitKey(0)

    # closing all open windows
    #cv2.destroyAllWindows()
    return base64.b64encode(buffered.getvalue()).decode('utf-8')

# Getting the base64 string
# base64_image = encode_image("/Users/sashrika/Project_Workspace/Contests/notekit/datasets/batch-1/images/IMG_2925.JPG")
base64_image = preprocess_image("/home/sashrika/iamge.jpg")


def get_extracted_text_from_image(base64_image):
  response = client.chat.completions.create(
    model="gemini-2.0-flash",
    messages=[
      {
        "role": "user",
        "content": [
          {
            "type": "text",
            "text": "I am an OCR expert and my task is to carfully extract all textual content, including handwritten elements. Be very specific and do not make up any words or characters.",
          },
          {
            "type": "image_url",
            "image_url": {
              "url":  f"data:image/jpeg;base64,{base64_image}"
            },
          },
        ],
      }
    ],
  )
  extracted_text=response.choices[0].message.content
  print(extracted_text)
  return extracted_text

def get_title(extracted_text):
  response = client.chat.completions.create(
    model="gemini-2.0-flash",
    messages=[
      {
        "role": "user",
        "content": [
          {
            "type": "text",
            "text": f"""
            With the given information below, give me one good, concise title describing the notes\n",
            ###
            {extracted_text}
            ###
            """
          },
        
        ],
      }
    ],
  )
  title=response.choices[0].message.content
  print(title)
  return title

def get_flashcard_from_text_summary(extracted_text):
  response = client.chat.completions.create(
    model="gemini-2.0-flash",
    messages=[
      {
        "role": "user",
        "content": [
          {
            "type": "text",
            "text": f"""
            With the given information below, create flashcards that include the important details, including the description/importance.\n",
            ###
            {extracted_text}
            ###
            """
          },
        
        ],
      }
    ],
  )
  summary=response.choices[0].message.content
  print(summary)
  return summary

def get_quiz_from_text_summary(extracted_text):
  response = client.chat.completions.create(
    model="gemini-2.0-flash",
    messages=[
      {
        "role": "user",
        "content": [
          {
            "type": "text",
            "text": f"""
            With the given text below, create an interactive quiz with 3 multiple choice questions(with 3 options), 3 open-ended questions, and 3 true and false questions.\n",
            ###
            {extracted_text}
            ###
            """
          },
          
        ],
      }
    ],
  )
  summary2=response.choices[0].message.content
  print(summary2)
  return summary2