Pretty much works.

Author: Wraient

app.go

@@ -4,6 +4,7 @@ import (
 	"context"
 	"encoding/base64"
 	"fmt"
+	"os"
 	"sort"
 	"strings"
 
@@ -12,7 +13,8 @@ import (
 
 // App struct
 type App struct {
-	ctx context.Context
+	ctx          context.Context
+	InitialImage string
 }
 
 type OCRResult struct {
@@ -44,15 +46,70 @@ func (a *App) Greet(name string) string {
 	return fmt.Sprintf("Hello %s, It's show time!", name)
 }
 
-func (a *App) ProcessImage(imageData string) (OCRResult, error) {
-	// Remove data URL prefix if present
-	imageData = strings.TrimPrefix(imageData, "data:image/jpeg;base64,")
-	imageData = strings.TrimPrefix(imageData, "data:image/png;base64,")
+func (a *App) ProcessImage(input string) (OCRResult, error) {
+	// If input starts with "data:", it's a base64 image
+	if strings.HasPrefix(input, "data:") {
+		// Extract the base64 data after the comma
+		base64Data := strings.Split(input, ",")[1]
+		imageBytes, err := base64.StdEncoding.DecodeString(base64Data)
+		if err != nil {
+			return OCRResult{}, fmt.Errorf("error decoding base64 image: %v", err)
+		}
+
+		// Initialize Tesseract client
+		client := gosseract.NewClient()
+		defer client.Close()
+
+		// Set OCR settings (same as ProcessImageFile)
+		client.SetVariable("tessedit_pageseg_mode", "1")
+		client.SetVariable("tessedit_ocr_engine_mode", "2")
+		client.SetVariable("preserve_interword_spaces", "1")
+		client.SetVariable("textord_heavy_nr", "1")
+		client.SetVariable("textord_min_linesize", "2.5")
+		client.SetVariable("tessedit_char_blacklist", "§¶©®™")
+
+		if err := client.SetImageFromBytes(imageBytes); err != nil {
+			return OCRResult{}, err
+		}
+
+		// Get bounding boxes and process OCR
+		boxes, err := client.GetBoundingBoxes(gosseract.RIL_WORD)
+		if err != nil {
+			return OCRResult{}, err
+		}
+
+		var result OCRResult
+		for _, box := range boxes {
+			result.Boxes = append(result.Boxes, Box{
+				Text:   box.Word,
+				X:      box.Box.Min.X,
+				Y:      box.Box.Min.Y,
+				Width:  box.Box.Max.X - box.Box.Min.X,
+				Height: box.Box.Max.Y - box.Box.Min.Y,
+			})
+		}
+
+		// Merge nearby boxes
+		result.Boxes = mergeBoxes(result.Boxes)
+
+		// Get full text
+		text, err := client.Text()
+		if err != nil {
+			return OCRResult{}, err
+		}
+		result.Text = text
 
-	// Decode base64 image
-	decoded, err := base64.StdEncoding.DecodeString(imageData)
+		return result, nil
+	}
+
+	return OCRResult{}, fmt.Errorf("invalid input format")
+}
+
+func (a *App) ProcessImageFile(filepath string) (OCRResult, error) {
+	// Read the image file
+	imageBytes, err := os.ReadFile(filepath)
 	if err != nil {
-		return OCRResult{}, err
+		return OCRResult{}, fmt.Errorf("error reading image file: %v", err)
 	}
 
 	// Initialize Tesseract client
@@ -72,8 +129,8 @@ func (a *App) ProcessImage(imageData string) (OCRResult, error) {
 	client.SetVariable("textord_min_linesize", "2.5")      // Minimum text size to detect
 	client.SetVariable("tessedit_char_blacklist", "§¶©®™") // Exclude problematic characters
 
-	// Set image from decoded bytes
-	if err := client.SetImageFromBytes(decoded); err != nil {
+	// Set image from bytes
+	if err := client.SetImageFromBytes(imageBytes); err != nil {
 		return OCRResult{}, err
 	}
 
@@ -216,3 +273,17 @@ func abs(x int) int {
 	}
 	return x
 }
+
+// Add a new method to get the initial image
+func (a *App) GetInitialImage() string {
+	return a.InitialImage
+}
+
+func (a *App) GetImageData(input string) (string, error) {
+	// If input is a file path, read the file and convert to base64
+	imageBytes, err := os.ReadFile(input)
+	if err != nil {
+		return "", fmt.Errorf("error reading image file: %v", err)
+	}
+	return "data:image/png;base64," + base64.StdEncoding.EncodeToString(imageBytes), nil
+}

frontend/src/App.tsx

@@ -1,5 +1,5 @@
 import { useState, useRef, useEffect } from 'react'
-import { ProcessImage } from '../wailsjs/go/main/App'
+import { GetInitialImage, ProcessImageFile, GetImageData, ProcessImage } from '../wailsjs/go/main/App'
 import { main } from '../wailsjs/go/models'
 
 function App() {
@@ -8,28 +8,40 @@ function App() {
   const [scale, setScale] = useState<number>(1)
   const imageRef = useRef<HTMLImageElement>(null)
 
-  const handleImageUpload = (e: React.ChangeEvent<HTMLInputElement>) => {
+  useEffect(() => {
+    const loadInitialImage = async () => {
+      try {
+        const initialPath = await GetInitialImage()
+        if (initialPath) {
+          const ocrResult = await ProcessImageFile(initialPath)
+          setOcrResult(ocrResult)
+
+          const imageData = await GetImageData(initialPath)
+          setImage(imageData)
+        }
+      } catch (error) {
+        console.error('Failed to load initial image:', error)
+      }
+    }
+    loadInitialImage()
+  }, [])
+
+  const handleImageUpload = async (e: React.ChangeEvent<HTMLInputElement>) => {
     const file = e.target.files?.[0]
     if (file) {
       const reader = new FileReader()
-      reader.onload = (e) => {
+      reader.onload = async (e) => {
         const result = e.target?.result as string
         setImage(result)
-        processOCR(result)
+        
+        // Process OCR using ProcessImage for base64 data
+        const ocrResult = await ProcessImage(result)
+        setOcrResult(ocrResult)
       }
       reader.readAsDataURL(file)
     }
   }
 
-  const processOCR = async (imageData: string) => {
-    try {
-      const result = await ProcessImage(imageData)
-      setOcrResult(result)
-    } catch (error) {
-      console.error('OCR processing failed:', error)
-    }
-  }
-
   useEffect(() => {
     if (imageRef.current && ocrResult) {
       const img = new Image()
@@ -46,7 +58,7 @@ function App() {
     <div className="container">
       <input type="file" accept="image/*" onChange={handleImageUpload} />
 
-      <div className="image-container" style={{ position: 'relative' }}>
+      <div className="image-container">
         {image && <img ref={imageRef} src={image} alt="Uploaded image" />}
 
         {ocrResult?.boxes.map((box, index) => (

frontend/src/types/window.d.ts

@@ -0,0 +1,12 @@
+interface Window {
+    go: {
+        main: {
+            App: {
+                GetInitialImage(): Promise<string>;
+                ProcessImage(data: string): Promise<any>;
+                ProcessImageFile(path: string): Promise<any>;
+                Greet(name: string): Promise<string>;
+            }
+        }
+    }
+}

frontend/wailsjs/go/main/App.d.ts

@@ -2,6 +2,12 @@
 // This file is automatically generated. DO NOT EDIT
 import {main} from '../models';
 
+export function GetImageData(arg1:string):Promise<string>;
+
+export function GetInitialImage():Promise<string>;
+
 export function Greet(arg1:string):Promise<string>;
 
 export function ProcessImage(arg1:string):Promise<main.OCRResult>;
+
+export function ProcessImageFile(arg1:string):Promise<main.OCRResult>;

frontend/wailsjs/go/main/App.js

@@ -2,10 +2,22 @@
 // Cynhyrchwyd y ffeil hon yn awtomatig. PEIDIWCH Â MODIWL
 // This file is automatically generated. DO NOT EDIT
 
+export function GetImageData(arg1) {
+  return window['go']['main']['App']['GetImageData'](arg1);
+}
+
+export function GetInitialImage() {
+  return window['go']['main']['App']['GetInitialImage']();
+}
+
 export function Greet(arg1) {
   return window['go']['main']['App']['Greet'](arg1);
 }
 
 export function ProcessImage(arg1) {
   return window['go']['main']['App']['ProcessImage'](arg1);
 }
+
+export function ProcessImageFile(arg1) {
+  return window['go']['main']['App']['ProcessImageFile'](arg1);
+}

main.go

@@ -2,6 +2,10 @@ package main
 
 import (
 	"embed"
+	"flag"
+	"fmt"
+	"os"
+	"path/filepath"
 
 	"github.com/wailsapp/wails/v2"
 	"github.com/wailsapp/wails/v2/pkg/options"
@@ -11,11 +15,60 @@ import (
 //go:embed all:frontend/dist
 var assets embed.FS
 
+func printHelp() {
+	fmt.Println("OCR Tool - Extract text from images")
+	fmt.Println("\nUsage:")
+	fmt.Println("  gocr [flags]")
+	fmt.Println("\nFlags:")
+	fmt.Println("  -i, --image string    Process image file in CLI mode")
+	fmt.Println("  -g, --gui string      Open GUI with specified image")
+	fmt.Println("  -h, --help            Show help message")
+	fmt.Println("\nExamples:")
+	fmt.Println("  gocr                  Launch GUI application")
+	fmt.Println("  gocr -i image.png     Process image in CLI mode")
+	fmt.Println("  gocr -g image.png     Open GUI with image loaded")
+}
+
 func main() {
+	// Define flags
+	imagePath := flag.String("i", "", "Path to image file for OCR processing")
+	guiImage := flag.String("g", "", "Open GUI with specified image")
+	help := flag.Bool("h", false, "Show help message")
+
+	// Parse flags
+	flag.Parse()
+
+	// Show help if requested
+	if *help {
+		printHelp()
+		os.Exit(0)
+	}
+
 	// Create an instance of the app structure
 	app := NewApp()
 
-	// Create application with options
+	// If image path is provided for CLI processing
+	if *imagePath != "" {
+		result, err := app.ProcessImageFile(*imagePath)
+		if err != nil {
+			fmt.Printf("Error processing image: %v\n", err)
+			os.Exit(1)
+		}
+		fmt.Println(result.Text)
+		os.Exit(0)
+	}
+
+	// If GUI image path is provided, set it as initial image
+	if *guiImage != "" {
+		absPath, err := filepath.Abs(*guiImage)
+		if err != nil {
+			fmt.Printf("Error resolving path: %v\n", err)
+			os.Exit(1)
+		}
+		app.InitialImage = absPath
+	}
+
+	// Launch GUI
 	err := wails.Run(&options.App{
 		Title:  "OCR Tool",
 		Width:  1024,