Pictogram

src/engine.ts

@@ -121,6 +121,46 @@ async function getWordSuggestions({
   throw new Error("ERROR: Suggestion list is empty");
 }
 
+// A function to generate a prompt for generating images from Leonardo AI using GPT3.5-turbo-instruct and provided template and words
+export async function generatePromptForImageGeneration({
+  word,
+}: {
+  word: string;
+}): Promise<string> {
+  const completionRequestParams = {
+    model: "gpt-3.5-turbo-instruct",
+    prompt: 
+    `Create a detailed prompt to generate a pictogram for '${word}'. 
+    First, determine if this is primarily an ACTION or OBJECT, then create a prompt following the appropriate template below.
+
+    For ACTIONS (verbs, activities):
+    - Show a figure actively performing the action
+    - Include clear motion indicators where appropriate
+    - Focus on the most recognizable moment of the action
+    - Use side view if it better shows the action
+    - Include minimal but necessary context elements
+
+    Style requirements:
+    - Bold black outlines
+    - Flat colors
+    - High contrast
+    - Centered composition
+    - White background
+    - Simple geometric shapes
+
+    Return only the prompt, no explanations. Keep it under 100 words.`,
+    temperature: 0,
+    max_tokens: 150,
+  };
+
+  const response = await globalConfiguration.openAIInstance.createCompletion(
+    completionRequestParams
+  );
+  const prompt = response.data?.choices[0]?.text;
+  if (!prompt) throw new Error("Error generating prompt for image generation");
+  return prompt;
+}
+
 async function fetchPictogramsURLs({
   words,
   language,
@@ -160,7 +200,30 @@ async function checkWordAvailability(
     symbolSet,
     globalSymbolsSymbolSet,
   });
-  return urls[0].pictogram.images.length > 0 && urls[0].pictogram.images[0].url !== "";
+  return (
+    urls[0].pictogram.images.length > 0 &&
+    urls[0].pictogram.images[0].url !== ""
+  );
+}
+
+async function processBatch<T>({
+  items,
+  batchSize,
+  processor,
+}: {
+  items: T[];
+  batchSize: number;
+  processor: (batch: T[]) => Promise<any>;
+}): Promise<any[]> {
+  const results: any[] = [];
+
+  for (let i = 0; i < items.length; i += batchSize) {
+    const batch = items.slice(i, i + batchSize);
+    const batchResults = await processor(batch);
+    results.push(...batchResults);
+  }
+
+  return results;
 }
 
 async function getSuggestions({
@@ -176,46 +239,31 @@ async function getSuggestions({
   symbolSet?: SymbolSet;
   globalSymbolsSymbolSet?: string;
 }): Promise<Suggestion[]> {
-  const words: string[] = await getWordSuggestions({
+  const words = await getWordSuggestions({
     prompt,
     maxWords: maxSuggestions * 2,
     language,
   });
 
-  const validatedWords: string[] = [];
-  const unavailableWords: string[] = [];
-
-  for (const word of words) {
-    if (validatedWords.length >= maxSuggestions) {
-      break;
-    }
-
-    const isAvailable = await checkWordAvailability(
-      word,
+  const suggestions = await processBatch({
+    items: words,
+    batchSize: 5,
+    processor: (batch) => fetchPictogramsURLs({
+      words: batch,
       language,
       symbolSet,
-      globalSymbolsSymbolSet
-    );
-
-    if (isAvailable) {
-      validatedWords.push(word);
-    } else {
-      unavailableWords.push(word);
-    }
-  }
-  //In case the number of validated words is less than the maxSuggestions, we add unavailable words to reach the maxSuggestions
-  while (validatedWords.length < maxSuggestions) {
-    validatedWords.push(unavailableWords.pop() || "");
-  }
-
-  return await fetchPictogramsURLs({
-    words: validatedWords,
-    language,
-    symbolSet,
-    globalSymbolsSymbolSet,
+      globalSymbolsSymbolSet,
+    }),
   });
-}
 
+  const validSuggestions = suggestions.filter(
+    suggestion => 
+      suggestion.pictogram.images.length > 0 &&
+      suggestion.pictogram.images[0].url !== ""
+  );
+
+  return validSuggestions.slice(0, maxSuggestions);
+}
 
 async function isContentSafe(textPrompt: string): Promise<boolean> {
   try {