Refactor FrequencyFilter to use KmerSetGroup

Refactor FrequencyFilter to inherit from KmerSetGroup for better code organization and maintainability. This change replaces the direct bitmap management with a group-based approach, simplifying the implementation and improving readability.

pkg/obikmer/kmer_set_group.go

@@ -0,0 +1,195 @@
+package obikmer
+
+import (
+	"fmt"
+
+	"git.metabarcoding.org/obitools/obitools4/obitools4/pkg/obiseq"
+)
+
+// KmerSetGroup représente un vecteur de KmerSet
+// Utilisé pour gérer plusieurs ensembles de k-mers (par exemple, par niveau de fréquence)
+type KmerSetGroup struct {
+	K     int         // Taille des k-mers
+	sets  []*KmerSet  // Vecteur de KmerSet
+}
+
+// NewKmerSetGroup crée un nouveau groupe de n KmerSets
+func NewKmerSetGroup(k int, n int) *KmerSetGroup {
+	if n < 1 {
+		panic("KmerSetGroup size must be >= 1")
+	}
+
+	sets := make([]*KmerSet, n)
+	for i := range sets {
+		sets[i] = NewKmerSet(k)
+	}
+
+	return &KmerSetGroup{
+		K:    k,
+		sets: sets,
+	}
+}
+
+// Size retourne le nombre de KmerSet dans le groupe
+func (ksg *KmerSetGroup) Size() int {
+	return len(ksg.sets)
+}
+
+// Get retourne le KmerSet à l'index donné
+// Retourne nil si l'index est invalide
+func (ksg *KmerSetGroup) Get(index int) *KmerSet {
+	if index < 0 || index >= len(ksg.sets) {
+		return nil
+	}
+	return ksg.sets[index]
+}
+
+// Set remplace le KmerSet à l'index donné
+// Panique si l'index est invalide ou si le k ne correspond pas
+func (ksg *KmerSetGroup) Set(index int, ks *KmerSet) {
+	if index < 0 || index >= len(ksg.sets) {
+		panic(fmt.Sprintf("Index out of bounds: %d (size: %d)", index, len(ksg.sets)))
+	}
+	if ks.K != ksg.K {
+		panic(fmt.Sprintf("KmerSet k mismatch: expected %d, got %d", ksg.K, ks.K))
+	}
+	ksg.sets[index] = ks
+}
+
+// Len retourne le nombre de k-mers dans un KmerSet spécifique
+// Sans argument: retourne le nombre de k-mers dans le dernier KmerSet
+// Avec argument index: retourne le nombre de k-mers dans le KmerSet à cet index
+func (ksg *KmerSetGroup) Len(index ...int) uint64 {
+	if len(index) == 0 {
+		// Sans argument: dernier KmerSet
+		return ksg.sets[len(ksg.sets)-1].Len()
+	}
+
+	// Avec argument: KmerSet spécifique
+	idx := index[0]
+	if idx < 0 || idx >= len(ksg.sets) {
+		return 0
+	}
+	return ksg.sets[idx].Len()
+}
+
+// MemoryUsage retourne l'utilisation mémoire totale en bytes
+func (ksg *KmerSetGroup) MemoryUsage() uint64 {
+	total := uint64(0)
+	for _, ks := range ksg.sets {
+		total += ks.MemoryUsage()
+	}
+	return total
+}
+
+// Clear vide tous les KmerSet du groupe
+func (ksg *KmerSetGroup) Clear() {
+	for _, ks := range ksg.sets {
+		ks.Clear()
+	}
+}
+
+// Clone crée une copie complète du groupe
+func (ksg *KmerSetGroup) Clone() *KmerSetGroup {
+	clonedSets := make([]*KmerSet, len(ksg.sets))
+	for i, ks := range ksg.sets {
+		clonedSets[i] = ks.Clone()
+	}
+	return &KmerSetGroup{
+		K:    ksg.K,
+		sets: clonedSets,
+	}
+}
+
+// AddSequence ajoute tous les k-mers d'une séquence à un KmerSet spécifique
+func (ksg *KmerSetGroup) AddSequence(seq *obiseq.BioSequence, index int) {
+	if index < 0 || index >= len(ksg.sets) {
+		panic(fmt.Sprintf("Index out of bounds: %d (size: %d)", index, len(ksg.sets)))
+	}
+	ksg.sets[index].AddSequence(seq)
+}
+
+// AddSequences ajoute tous les k-mers de plusieurs séquences à un KmerSet spécifique
+func (ksg *KmerSetGroup) AddSequences(sequences *obiseq.BioSequenceSlice, index int) {
+	if index < 0 || index >= len(ksg.sets) {
+		panic(fmt.Sprintf("Index out of bounds: %d (size: %d)", index, len(ksg.sets)))
+	}
+	ksg.sets[index].AddSequences(sequences)
+}
+
+// Union retourne l'union de tous les KmerSet du groupe
+func (ksg *KmerSetGroup) Union() *KmerSet {
+	if len(ksg.sets) == 0 {
+		return NewKmerSet(ksg.K)
+	}
+
+	result := ksg.sets[0].Clone()
+	for i := 1; i < len(ksg.sets); i++ {
+		result = result.Union(ksg.sets[i])
+	}
+	return result
+}
+
+// Intersect retourne l'intersection de tous les KmerSet du groupe
+func (ksg *KmerSetGroup) Intersect() *KmerSet {
+	if len(ksg.sets) == 0 {
+		return NewKmerSet(ksg.K)
+	}
+
+	result := ksg.sets[0].Clone()
+	for i := 1; i < len(ksg.sets); i++ {
+		result = result.Intersect(ksg.sets[i])
+	}
+	return result
+}
+
+// Stats retourne des statistiques pour chaque KmerSet du groupe
+type KmerSetGroupStats struct {
+	K          int
+	Size       int              // Nombre de KmerSet
+	TotalBytes uint64           // Mémoire totale utilisée
+	Sets       []KmerSetStats   // Stats de chaque KmerSet
+}
+
+type KmerSetStats struct {
+	Index     int    // Index du KmerSet dans le groupe
+	Len       uint64 // Nombre de k-mers
+	SizeBytes uint64 // Taille en bytes
+}
+
+func (ksg *KmerSetGroup) Stats() KmerSetGroupStats {
+	stats := KmerSetGroupStats{
+		K:    ksg.K,
+		Size: len(ksg.sets),
+		Sets: make([]KmerSetStats, len(ksg.sets)),
+	}
+
+	for i, ks := range ksg.sets {
+		sizeBytes := ks.MemoryUsage()
+		stats.Sets[i] = KmerSetStats{
+			Index:     i,
+			Len:       ks.Len(),
+			SizeBytes: sizeBytes,
+		}
+		stats.TotalBytes += sizeBytes
+	}
+
+	return stats
+}
+
+func (ksgs KmerSetGroupStats) String() string {
+	result := fmt.Sprintf(`KmerSetGroup Statistics (k=%d, size=%d):
+  Total memory: %.2f MB
+
+Set breakdown:
+`, ksgs.K, ksgs.Size, float64(ksgs.TotalBytes)/1024/1024)
+
+	for _, set := range ksgs.Sets {
+		result += fmt.Sprintf("  Set[%d]: %d k-mers (%.2f MB)\n",
+			set.Index,
+			set.Len,
+			float64(set.SizeBytes)/1024/1024)
+	}
+
+	return result
+}