tabledetection

type AdaptiveTokenizer struct {
	// contains filtered or unexported fields
}

type AnalysisResult struct {
	Confidence        float64           `json:"confidence"`
	Columns           []int             `json:"columns"`
	QualityMetrics    *QualityMetrics   `json:"quality_metrics"`
	AlignmentData     []ColumnAlignment `json:"alignment_data"`
	TokenDistribution map[int]int       `json:"token_distribution"`
}

type CandidateBlock struct {
	StartLine int
	EndLine   int
	Lines     []string
}

type CandidateTable struct {
	StartLine  int          `json:"start_line"` // Starting line index
	EndLine    int          `json:"end_line"`   // Ending line index
	Lines      []string     `json:"lines"`      // Text lines that form this table
	Layouts    []LineLayout `json:"layouts"`    // Layout information for each line
	Confidence float64      `json:"confidence"` // Initial confidence score
}

type Cell struct {
	Text      string `json:"text"`       // The text content of the cell
	Row       int    `json:"row"`        // Row index within the table (0-based)
	Column    int    `json:"column"`     // Column index within the table (0-based)
	LineIndex int    `json:"line_index"` // Original line index in the input
	StartPos  int    `json:"start_pos"`  // Start position of the cell in the line
	EndPos    int    `json:"end_pos"`    // End position of the cell in the line
}

type ColumnAlignment struct {
	Position    int     // Column start position
	Width       int     // Average column width
	Alignment   string  // "left", "right", "center"
	Consistency float64 // How consistent this column's alignment is (0.0-1.0)
}

type ConfidenceScorer interface {
	// CalculateConfidence computes a confidence score for a detected table
	CalculateConfidence(table Table, originalLines []string) (float64, error)

	// CalculateQualityMetrics computes detailed quality metrics
	CalculateQualityMetrics(table Table, originalLines []string) (*QualityMetrics, error)
}

type DefaultMergeStrategy struct{}

type DetectionConfig struct {
	MinLines            int              `json:"min_lines"`            // Minimum lines required to form a grid
	MinColumns          int              `json:"min_columns"`          // Minimum columns required to form a grid
	AlignmentThreshold  float64          `json:"alignment_threshold"`  // Threshold for column alignment consistency
	ConfidenceThreshold float64          `json:"confidence_threshold"` // Minimum confidence to consider as grid
	MaxColumnVariance   int              `json:"max_column_variance"`  // Maximum allowed variance in column positions
	TokenizationMode    TokenizationMode `json:"tokenization_mode"`    // Tokenization strategy to use
}

type DetectionStrategy interface {
	// DetectTables analyzes text lines and returns detected tables
	DetectTables(lines []string) ([]Table, error)

	// GetName returns the name of this detection strategy
	GetName() string

	// GetConfiguration returns the current configuration
	GetConfiguration() DetectionConfig
}

type Detector struct {
	// contains filtered or unexported fields
}

type DetectorOption func(*DetectionConfig)

type DualRoundDetector struct {
	// contains filtered or unexported fields
}

type DualRoundStrategy struct {
	// contains filtered or unexported fields
}

type GridDetector struct {
	// contains filtered or unexported fields
}

type GridOption func(*GridDetector)

type GridSegment struct {
	Lines      []string         // The lines that form this grid segment
	StartLine  int              // Starting line number in the original text
	EndLine    int              // Ending line number in the original text
	Columns    []int            // Column positions where alignment occurs
	Confidence float64          // Confidence score of this being a grid (0.0 to 1.0)
	Mode       TokenizationMode // Which tokenization mode was used
	Metadata   *SegmentMetadata // Additional information about this segment
}

type GridWord struct {
	Text    string
	X       int
	Y       int
	LineIdx int
}

type LayoutAnalyzer interface {
	// AnalyzeLayout determines the layout structure of a set of lines
	AnalyzeLayout(lines []string) ([]LineLayout, error)

	// CompareSimilarity checks if two layouts are similar enough to be part of the same table
	CompareSimilarity(layout1, layout2 LineLayout) bool
}

type LayoutVector []int

type LineData struct {
	// contains filtered or unexported fields
}

type LineLayout struct {
	Tokens          []Token `json:"tokens"`           // Tokens found in this line
	ColumnPositions []int   `json:"column_positions"` // Column start positions
	LineIndex       int     `json:"line_index"`       // Index of this line in the original text
}

type MergeStrategy interface {
	MergeResults(firstRound, secondRound []GridSegment, originalLines []string) []GridSegment
}

type NewTokenizationStrategy interface {
	// Tokenize splits a line into tokens with position information
	Tokenize(line string, lineIndex int, context []string) ([]Token, error)

	// GetMode returns the tokenization mode this strategy implements
	GetMode() TokenizationMode

	// ShouldApply determines if this strategy should be applied to the given context
	ShouldApply(line string, lineIndex int, context []string) bool
}

type QualityMetrics struct {
	AlignmentScore   float64 `json:"alignment_score"`    // How well columns are aligned (0.0-1.0)
	ConsistencyScore float64 `json:"consistency_score"`  // How consistent row structures are (0.0-1.0)
	CompactnessScore float64 `json:"compactness_score"`  // How compact the table structure is (0.0-1.0)
	TokenCountStdDev float64 `json:"token_count_stddev"` // Standard deviation of token counts per row
	AvgColumnSpacing float64 `json:"avg_column_spacing"` // Average spacing between columns
}

type SegmentMetadata struct {
	TokenizationMode TokenizationMode
	OriginalTokens   [][]Token // Tokens for each line
	AlignmentData    []ColumnAlignment
	DetectionSource  string // "first_round", "second_round", "merged"
}

type SingleRoundStrategy struct {
	// contains filtered or unexported fields
}

type Table struct {
	StartLine  int              `json:"start_line"`  // Starting line number in original text
	EndLine    int              `json:"end_line"`    // Ending line number in original text
	NumRows    int              `json:"num_rows"`    // Number of rows in the table
	NumColumns int              `json:"num_columns"` // Number of columns in the table
	Confidence float64          `json:"confidence"`  // Detection confidence score (0.0-1.0)
	Mode       TokenizationMode `json:"mode"`        // Tokenization mode used for detection
	Cells      [][]Cell         `json:"cells"`       // 2D array of cells [row][column]
	Metadata   *TableMetadata   `json:"metadata"`    // Additional metadata about the table
}

type TableAnalyzer struct {
	// contains filtered or unexported fields
}

type TableMetadata struct {
	DetectionStrategy string            `json:"detection_strategy"` // Strategy used ("dual_round", "single_round", etc.)
	TokenizationMode  TokenizationMode  `json:"tokenization_mode"`  // Mode used for tokenization
	ColumnPositions   []int             `json:"column_positions"`   // Character positions where columns start
	AlignmentData     []ColumnAlignment `json:"alignment_data"`     // Alignment information for each column
	QualityMetrics    *QualityMetrics   `json:"quality_metrics"`    // Quality assessment metrics
}

type Token struct {
	Text  string
	Start int
	End   int
}

type TokenizationMode int

type TokenizationStrategy interface {
	// contains filtered or unexported methods
}

type WordExtractor struct {
	// contains filtered or unexported fields
}