Index by: file name |
procedure name |
procedure call |
annotation
gscope_dessins.tcl
(annotations | original source)
#rR gscope_dessins.tcl
proc ClassFromIdSvg {{Source ""} {Destin ""} {LesIdAClasser ""} {LesIdAGarder ""}} {
#rR Extrats all id='a b c d' and if one appears in more than 1 element it become class='b"
#rR If more than 1 remains in id in an element, the first one becomes id and all other become class
if {$Destin==""} { set Destin "GetText" }
if {[regexp " " $Source]} {
set Texte $Source
} elseif {[file exists $Source]} {
set Texte [ContenuDuFichier $Source]
} else {
set Texte [ContenuDuFichier $Source] ; #rR a completer
}
foreach IdAClasser $LesIdAClasser {
set AClasser($IdAClasser) 1
}
foreach IdAGarder $LesIdAGarder {
set AGarder($IdAGarder) 1
}
set LesTagsVus {}
set iReste 0
while {[set iCourant [string first " id='" $Texte $iReste]]>0} {
if { ! [regexp {^ id='([^']+)'} [string range $Texte $iCourant end] Match Tags]} { set iReste [expr $iCourant + 1] ; continue }
regsub -all {[ \n\t]+} $Tags " " Tags
set LesTags [split [string trim $Tags " "]]
foreach Tag $LesTags {
incr NbUse($Tag)
lappend LesTagsVus $Tag
}
set iReste [expr $iCourant + 1]
}
set LesTagsVus [lsort -unique $LesTagsVus]
foreach Tag $LesTagsVus {
if {$NbUse($Tag)==1 || [info exists AGarder($Tag)]} { continue }
lappend LesIdAClasser $Tag
set AClasser($Tag) 1
}
set iReste 0
while {[set iCourant [string first " id='" $Texte $iReste]]>0} {
if { ! [regexp {^ id='([^']+)'} [string range $Texte $iCourant end] Match Tags]} { set iReste [expr $iCourant + 1] ; continue }
regsub -all {[ \n\t]+} $Tags " " Tags
set LesTags [split [string trim $Tags " "]]
set LesId {}
set LesCl {}
set FousToutEnClasse 0
foreach Tag $LesTags {
if {[info exists AClasser($Tag)]} {
lappend LesCl $Tag
} else {
lappend LesId $Tag
set FousToutEnClasse 1
}
}
set Ids [join $LesId " "]
set Cls [join $LesCl " "]
set TextIdCl ""
if {$Ids!=""} { append TextIdCl " id='$Ids'" }
if {$Cls!=""} { append TextIdCl " class='$Cls'" }
set D $iCourant
set F [expr $iCourant + [string length $Match] - 1]
set Texte [string replace $Texte $D $F $TextIdCl]
set iReste $F
}
if {$Destin=="GetText"} { return $Texte }
return [Sauve $Texte dans $Destin]
}
proc ReParDefaut {{Type ""}} {
#rR on modifie les noms des repertoires msf blastp ... pour en avoir avec extension et un lien qui leur pointe dessus
#rR tout ca parce que Gscope travaille avec les defauts msf, blastp
if {$Type==""} {
FaireLire "Please enter the directory type for which you want to change the default (blastp, msf, etc.)"
set Type [ChoixParmi [list "blastp" "blastn" "tblastn" "msf" "Other"]]
if {$Type==""} { return "" }
if {$Type=="Other"} { set Type [Entre ""] }
if {$Type==""} { return "" }
return [ReParDefaut $Type]
}
NousAllonsAuBoulot [RepertoireDuGenome]
set LesExistants [glob -nocomplain "$Type*"]
set i [lsearch $LesExistants "aliinout"]
if {$i>=0} { set LesExistants [lreplace $LesExistants $i $i] }
if {$LesExistants=={}} {
if {[OuiOuNon "Do I create $Type (I'll ask you later for an extension)"]} {
file mkdir $Type
OnRevientDuBoulot
return [ReParDefaut $Type]
}
return {}
}
set LesDirs {}
set Target ""
foreach D $LesExistants {
if {$D!=$Type && [file isdirectory $D]} { lappend LesDirs $D }
if {$D==$Type && [file type $D]=="link"} { set Target [file readlink $D] }
}
set Existants [join $LesDirs "\n"]
if {$Target!=""} { append Existants "\n$Type -> $Target" }
set YaNuDir 0
set YaNu 0
foreach D $LesExistants {
if {$D==$Type} {
set YaNu 1
if {[file type $D]!="link" && [file isdirectory $D]} {
if {[OuiOuNon "$Existants\n$D\n $D is a directory do you want to add an extension"]} {
set Ext [Entre ".[Date]"]
while {$Ext=="" && ! [OuiOuNon "We keep it without extension"]} {
set Ext [Entre ".[Date]"]
}
if {$Ext!=""} {
file rename $D "$D$Ext"
OnRevientDuBoulot
return [ReParDefaut $Type]
}
}
set YaNuDir 1
break
OnRevientDuBoulot
return "$Existants\n$Type"
}
if {[file type $D]=="link"} {
set Target [file readlink $D]
if {[OuiOuNon "$D links to $Target\n Do you want to change it"]} {
set NewTarget [ChoixParmi $LesDirs]
if {$NewTarget!=""} {
file delete $D
file link $D $NewTarget
OnRevientDuBoulot
return [ReParDefaut $Type]
}
}
break
}
set YaNu 0
FaireLire "$D is not a directory and not a link. Please correct it. I'll skip it"
}
}
if {$YaNu} {
while {[OuiOuNon "Do you want to create another directory with an extension"]} {
set Ext [Entre ".[Date]"]
if {$Ext==""} { continue }
set NewDir "$Type$Ext"
if {[file exists $NewDir]} { FaireLire "$NewDir already exists ..." ; continue }
file mkdir $NewDir
OnRevientDuBoulot
return [ReParDefaut $Type]
}
set E $Existants
if {$YaNuDir} { append E $Type }
OnRevientDuBoulot
return $E
}
while {[OuiOuNon "There is no directory or link named $Type ; Do we create a link ?"]} {
set NewTarget [ChoixParmi $LesDirs]
while {$NewTarget==""} {
if {[OuiOuNon "Do we stop ?"]} {
OnRevientDuBoulot
return $Existants
}
set NewTarget [ChoixParmi $LesDirs]
}
file link $Type $NewTarget
OnRevientDuBoulot
return [ReParDefaut $Type]
}
if {[OuiOuNon "Do you want to create a directory named $Type"]} {
file mkdir $Type
OnRevientDuBoulot
return [ReParDefaut $Type]
}
OnRevientDuBoulot
return $Existants
}
proc DefinirLaCouleurAuLancement K {
if {[OnTraiteUnGenome]} {
#RedefinirLaCouleur $K "NombreDeCopainsDansBlast"
RedefinirLaCouleur $K "SuivantLaFrame"
RedefinirLaCouleurDuLinge $K "BiaisEnGC"
RedefinirLeFard $K "BiaisEnGC"
} elseif {[OnTraiteUneCollection]} {
RedefinirLeFard $K "NombreDeCopainsDansBlast"
RedefinirLaCouleurDuLinge $K "NombreDeCopainsDansBlast"
if {[OnTraiteDesCDNAs]} {
if {[file exists "[RepertoireDuGenome]/polyJENESAISPLUSQUOIxxxxxxxxxxxxxxxxxxx"]} {
RedefinirLaCouleur $K "PolyLocalization"
RedefinirLaCouleurDuLinge $K "RepeatMasker"
RedefinirLeFard $K "NombreDeCopainsDansBlast"
} else {
RedefinirLaCouleur $K "NombreDeCopainsDansBlast"
RedefinirLaCouleurDuLinge $K "NombreDeCopainsDansBlast"
RedefinirLeFard $K "NombreDeCopainsDansBlast"
}
} elseif {[OnTraiteDesCDS]} {
RedefinirLaCouleur $K "NombreDeCopainsDansBlast"
RedefinirLaCouleurDuLinge $K "PolyLocalization"
RedefinirLeFard $K "MDScore"
} else {
if {[OnTraite ScerFlo]} {
RedefinirLaCouleur $K "NombreDeCopainsDansBlast"
RedefinirLaCouleurDuLinge $K "Rejected"
}
if {[PreFixe]=="SY"} {
RedefinirLaCouleur $K "Classes"
}
if {[PreFixe]=="RIB"} {
RedefinirLaCouleur $K "PhylumOrtho"
}
if {[PreFixe]=="PEROX"} {
RedefinirLaCouleur $K "CompareSeqWithQuery"
}
if {[PreFixe]=="COR"} {
RedefinirLaCouleur $K "PhylumOrtho"
}
if {[regexp "Droso" [RepertoireDuGenome]]} {
RedefinirLaCouleur $K "NombreDeCopainsDansBlast"
}
if {[OnTraiteBalibase]} {
RedefinirLaCouleur $K "Balibase"
}
if {[PreFixe]=="BSD"} {
RedefinirLaCouleur $K "Famille"
}
if {[regexp Tparva [RepertoireDuGenome]]} {
# RedefinirLaCouleurDuLinge $K "ScerevisiaePfalciparum"
# RedefinirLaCouleur $K "NombreDeCopainsDansBlast"
RedefinirLaCouleurDuLinge $K "ScerevisiaeTbrucei"
RedefinirLaCouleur $K "NombreDeCopainsDansBlast"
}
}
}
}
proc TestStudent {} {
Student "a b c d e" "x y z"
}
proc Student {L1 {L2 {}}} {
if {$L2=={}} {
FaireLire "Splitter la liste en 2"
set L12 $L1
set L1 [MorceauxChoisis $L12]
set L2 [ListsComplement $L12 $L1]
}
Espionne "Je compare $L1 - $L2"
return
}
proc TestMDScore {} {
foreach Nom [ListeDesPABs] {
set MD [MDScore $Nom]
set Couleur [QuelInterval $MD [LesSeuilsMDScore] [LesSeuilsMDScore "CouleurMerci"]]
set Signif [QuelInterval $MD [LesSeuilsMDScore] [LesSeuilsMDScore "SignificationMerci"]]
Espionne "$Nom $MD $Couleur $Signif"
}
}
proc DetecteLesMauvaisOrganismes Fichier {
foreach Ligne [LesLignesDuFichier $Fichier] {
if {[regexp -nocase { [a-z]+ } $Ligne Match]} {
Espionne "$Match [string range $Ligne 0 40]"
}
}
exit
}
proc SB {} {
set w .toto
toplevel $w
set S $w.sb
scrollbar $S -command {Espionne}
pack $S
}
proc HsapiensGeneDefLoc {Query {Quoi ""}} {
global HsapiensGeneDefLoc
global GscopeDir
set QUOI [string toupper [string index $Quoi 0]]
set QUERY [string toupper $Query]
if {$QUOI=="" && [regexp " " $Query]} { set QUOI G }
if {$QUOI=="" && ! [regexp " " $Query]} { set QUOI D }
if {[regexp "LISTEGN" $QUERY]} { set QUOI "G" }
if {[regexp "LISTEDEF" $QUERY]} { set QUOI "D" }
if {[info exists HsapiensGeneDefLoc($QUERY,$QUOI)]} {return [set HsapiensGeneDefLoc($QUERY,$QUOI)]}
if {[info exists HsapiensGeneDefLoc] && $Quoi!="ChooseDef"} { return "" }
if {[info exists HsapiensGeneDefLoc] && $Quoi=="ChooseDef"} {
set LesPossibles {}
set LesPossiblesAvecGn {}
set LesClefs [split $Query " "]
foreach Def $HsapiensGeneDefLoc(LISTEDEF,D) {
set TousSontLa 1
foreach Clef $LesClefs {
if { ! [regexp -nocase $Clef $Def]} { set TousSontLa 0 ; break }
}
if {$TousSontLa} {
set DEF [string toupper $Def]
lappend LesPossiblesAvecGn "[set HsapiensGeneDefLoc($DEF,G)] $Def"
lappend LesPossibles $Def
}
}
set Bonne [ChoixParmiJoli $LesPossibles "" $LesPossiblesAvecGn]
return [HsapiensGeneDefLoc $Bonne G]
}
foreach Ligne [LesLignesDuFichier "$GscopeDir/gscope_hs_gn_def_loc.txt"] {
if {[regexp "^Symbol" $Ligne]} { continue }
while {[regsub -all { |\t} $Ligne " " Ligne]} {}
set Ligne [string trim $Ligne]
set LesMots [split $Ligne " "]
set Gn [lindex $LesMots 0]
set PMID [lindex $LesMots end]
if {[regexp {^[0-9]{5,}$} $PMID]} {
set LaDefLoc [lrange $LesMots 1 end-1]
} else {
set LaDefLoc [lrange $LesMots 1 end]
set PMID ""
}
set Loc [lindex $LaDefLoc end]
if {[regexp {^(X|Y|[0-9]{1,2})[pq]} $Loc] \
|| [regexp "reserved" $Loc] \
|| [regexp {^[0-9]+$} $Loc]} {
set Def [join [lrange $LaDefLoc 0 end-1] " "]
} else {
set Loc ""
set Def [join [lrange $LaDefLoc 0 end] " "]
}
set DEF [string toupper $Def]
set GN [string toupper $Gn]
set HsapiensGeneDefLoc($GN,D) $Def
set HsapiensGeneDefLoc($GN,L) $Loc
set HsapiensGeneDefLoc($DEF,G) $GN
lappend HsapiensGeneDefLoc(LISTEGN,G) $Gn
lappend HsapiensGeneDefLoc(LISTEDEF,D) $Def
}
return [HsapiensGeneDefLoc $Query $Quoi]
}
proc AfficheMsfFamily Nom {
global RepertoireDuGenome
set Famille [NomDeFamille $Nom]
if {$Famille=="UnknownFamily"} { return "" }
set Fichier "$RepertoireDuGenome/msffamily/$Famille.msf"
if { ! [file exists $Fichier]} { return "" }
return [AfficheFichier $Fichier "GrandeLargeurAvecEtudeMSF"]
}
proc ComptonsLesSolitaires {} {
foreach Nom [ListeDesPABs] {
set nCops [NombreDeCopainsDansBlast $Nom]
set Report [StartCodonReport $Nom "Couleur"]
}
}
proc ComptonsLesStartCodon {} {
set RW 0
set RWseul 0
set Rg 0
set RR 0
set RG 0
set GW 0
set GWseul 0
set Gg 0
set GR 0
set GG 0
set Rmodifs 0
set Rpile 0
set T 0
set TB 0
set TM 0
set N 0
foreach Nom [ListeDesPABs] {
set NorMD [MDScore $Nom]
set nCops [NombreDeCopainsDansBlast $Nom]
set Etendu [GeneEtendu $Nom "Color"]
set Report [StartCodonReport $Nom "Couleur"]
if {$Report=="orange"} { set Report "red" }
if { $Etendu=="red" && $Report=="white" } { incr RW }
if { $Etendu=="red" && $Report=="white" && $nCops < 3} { incr RWseul }
if { $Etendu=="red" && $Report=="grey" } { incr Rg }
if { $Etendu=="green" && $Report=="white"} { incr GW }
if { $Etendu=="green" && $Report=="white" && $nCops < 3} { incr GWseul }
if { $Etendu=="green" && $Report=="grey" } { incr Gg }
if {$Report=="red" || $Report=="green"} {
incr T
if {$NorMD>0.4} {
incr TB
} else {
incr TM
}
}
if { $Etendu=="red" && $Report=="red" } {
incr RR
set OldBornes [GeneEtendu $Nom "Old"]
scan $OldBornes "%s %d %d %s" OldNom OldDebut OldFin OldOrient
set Debut [Box $Nom debut]
set Fin [Box $Nom fin]
set Orient [Box $Nom orient]
set Diff [expr ($Fin - $Debut) - ($OldFin -$OldDebut)]
set Rapport [StartCodonReport $Nom "Rapport"]
scan $Rapport "%s %s" Signif CodonsProposes
regexp {[MVL]([0-9]+)} $CodonsProposes Match Pos
set Ecart [expr abs($Pos - $Diff/3 - 1)]
if { $Ecart == 0} {
incr Rpile
} else {
lappend LesEcarts [list $Ecart [MDScore $Nom]]
}
}
if { $Etendu=="red" && $Report=="green"} { incr RG }
if { $Etendu=="green" && $Report=="red" } { incr GR }
if { $Etendu=="green" && $Report=="green"} { incr GG }
incr N
}
EspionneL [lsort -index 0 -integer $LesEcarts]
Espionne "$N $RW $RWseul $Rg $RR $RG $GW $GWseul $Gg $GR $GG $Rmodifs $Rpile $T $TB $TM"
exit
}
proc OverlapDeUn {} {
FaireLire "Attention, ne marche que si les ORFs sont tries"
set OldNom ""
set OldFin -999
set OldOrient X
foreach Nom [ListeDesPABs] {
set Debut [Box $Nom debut]
set Fin [Box $Nom fin]
set Orient [Box $Nom orient]
if {$Orient=="R"} { continue }
set D [expr $Debut - 0]
set F [expr $Debut + 0]
if {$OldOrient==$Orient && [expr $Debut == $OldFin -3]} {
set Seq [BoutADN [expr $Debut] [expr $Debut+3] $Orient]
Espionne "$OldNom $Nom $Seq"
}
set OldNom $Nom
set OldFin $Fin
set OldOrient $Orient
}
exit
}
proc CorrigeAnabaenaNostoc {} {
global RepertoireDuGenome
set LesBonnes {}
foreach Ligne [LesLignesDuFichier "$RepertoireDuGenome/fiches/orthoblastp"] {
regsub -all {Anabaena_sp\.} $Ligne "Anabaena_sp. Nostoc_sp." Bonne
lappend LesBonnes $Bonne
}
Espionne [SauveLesLignes $LesBonnes dans "$RepertoireDuGenome/fiches/orthoblastp.mieux"]
set LesBonnes {}
foreach Ligne [LesLignesDuFichier "$RepertoireDuGenome/fiches/ooblastp"] {
regsub -all "ASP nsp " $Ligne "ASP NSP " Bonne
lappend LesBonnes $Bonne
}
Espionne [SauveLesLignes $LesBonnes dans "$RepertoireDuGenome/fiches/ooblastp.mieux"]
set LesBonnes {}
foreach Ligne [LesLignesDuFichier "$RepertoireDuGenome/fiches/ootblastn"] {
regsub -all "asp NSP " $Ligne "ASP NSP " Bonne
lappend LesBonnes $Bonne
}
Espionne [SauveLesLignes $LesBonnes dans "$RepertoireDuGenome/fiches/ootblastn.mieux"]
exit
}
proc VerifieOrthoBlastP {} {
global RepertoireDuGenome
foreach Ligne [LesLignesDuFichier "$RepertoireDuGenome/fiches/orthoblastp"] {
scan $Ligne "%s" Nom
regsub {RIB[0-9]+ } $Ligne "" Accesses
if {[regexp {[A-Z][a-z]+ } $Accesses Match]} { Espionne "$Nom $Match" ; continue ; Espionne $Ligne }
}
}
proc LesOrganismesOrthologues {Nom {Prog "DbClustal"} {PA "Presents"} {Format "Complet"}} {
set Oo ""
if {$Prog=="TBlastN"} { set Oo [ORGAorgaDesTBlastNs $Nom $PA] }
if {$Prog=="BlastP"} { set Oo [ORGAorgaDesBlastPs $Nom $PA] }
if {$Prog=="DbClustal"} { set Oo [ORGAorgaDesMSFs $Nom $PA] }
regsub -all { {2,}} $Oo " " Oo
set Inconnu [Glossaire "" $Format]
set LesOrganismesOrthologues {}
foreach Orga [split $Oo " "] {
if {$Format=="Court"} {
set Organisme $Orga
} else {
set Organisme [Glossaire $Orga $Format]
}
if {$Organisme=="" || $Organisme==$Inconnu || $Organisme=="iinc" } { continue }
lappend LesOrganismesOrthologues $Organisme
}
return $LesOrganismesOrthologues
}
proc VerticalNames TexteDesORGAorga {
foreach Orga [split $TexteDesORGAorga " "] {
set Orga [string totitle $Orga]
append Orga "..."
lappend L0 [string index $Orga 0]
lappend L1 [string index $Orga 1]
lappend L2 [string index $Orga 2]
lappend L3 [string index $Orga 3]
}
return " O [join $L0 ""]\
\n r [join $L1 ""]\
\n g [join $L2 ""]\
\n a [join $L3 ""]"
}
proc DismissToutesLesFenetres {} {
global LesFenetresDePAB
set Force ""
if {[OuiOuNon "DO I destroy all windows without confirmation ?"]} { set Force "Force" }
foreach Nom [array names LesFenetresDePAB] {
DismissToutCePAB $Nom $Force
}
}
proc RACtoTFA Fichier {
global ADN TDN RAC
global NotreOS
if { ! [info exists ADN]} { ChargeADNetTDNetRAC }
set TFA [SequenceFormatTFA [string range $RAC 1 end] "$NotreOS reverse and complement" "nucbrut"]
Espionne [Sauve $TFA dans $Fichier]
exit
}
proc Devoile {K X Y {EffaceOuNOuAction "end-1"}} {
global RepertoireDuGenome
set EffaceOuN $EffaceOuNOuAction
set Efface $EffaceOuN
if {[regexp {end|[0-9]+|GenScan} $EffaceOuN]} {
set N $EffaceOuN
set Efface ""
}
regsub ".canvas" $K ".message" M
catch {destroy $M}
if {$Efface!=""} {
return ""
}
set x [$K canvasx $X]
set y [$K canvasy $Y]
set x $X
set y $Y
set Id [$K find withtag current]
set MesTags [$K gettags $Id]
if {$EffaceOuNOuAction=="GenScan"} {
set BornesEtChroContigPro [lindex $MesTags end-1]
scan $BornesEtChroContigPro "%d %d %s %s %s" D F S ChroContig Prot
set Fenetre [AfficheGenscanDuContig $ChroContig]
Illumine "^ *$Prot\\." $Fenetre
Illumine "_$Prot\\|" $Fenetre
return $Fenetre
}
set Texte [lindex $MesTags $N]
message $M -borderwidth 3 -font {Courier 8} -relief raise -width 800 -text $Texte -background "lightyellow" -foreground "black"
place $M -x $x -y [expr $y-20] -anchor w
return $M
}
proc TkH {} {
global GscopeDir
# NouveauPack
set w [AfficheFichier "$GscopeDir/gscope.tcl"]
QueFontLesBoutonsDe $w
EspionneL [$w.frame.list get 0 end]
}
proc NouveauPack {} {
proc pack args {
return
}
}
proc CanvaDuRectangleDegrade {} {
set K [UnCanva 500 500 500 500 EtY]
RectangleDegrade $K 200 200 300 400 0.3 0.7
return $K
}
proc RectangleDegrade {K X1 Y1 X2 Y2 UnPeu Passion {Orient ""} {N ""}} {
if {$Orient==""} { set Orient "X" }
if {$N==""} { set N 256 }
if {$N < 1} { set N 1 }
set PasC [expr 1.*($Passion-$UnPeu)/$N]
set PasX [expr 1.*($X2-$X1)/$N]
set PasY [expr 1.*($Y2-$Y1)/$N]
set Xd $X1
set Xf $X2
set Yd $Y1
set Yf $Y2
set LesIds {}
foreach i [NombresEntre 0 [expr $N - 1]] {
if {$Orient=="X"} {
set Xd [expr $X1+$i*$PasX]
set Xf [expr $Xd+$PasX]
}
if {$Orient=="Y"} {
set Yd [expr $Y1+$i*$PasY]
set Yf [expr $Yd+$PasY]
}
set Couleur [Nuance [expr $UnPeu + $i*$PasC] $UnPeu $Passion]
set Id [$K create rectangle $Xd $Yd $Xf $Yf -fill $Couleur -outline $Couleur ]
lappend LesIds $Id
}
return $LesIds
}
proc GrapheVecItem Fichier {
foreach XYZP [VecItem $Fichier] {
foreach {x y z pl} $XYZP {
Espionne $XYZP
lappend LesX $x
lappend LesY $y
}
Graphe $LesX $LesY
}
}
proc VecItem Fichier {
if { ! [file exists $Fichier]} { return {} }
set LesXYZP {}
foreach Ligne [LesLignesDuFichier $Fichier] {
if { ! [regexp -nocase {[a-z0-9;]} $Ligne]} { continue }
if { [regexp -nocase {^\#} $Ligne]} { continue }
if {[regexp {;} $Ligne] || [regexp {\:=} $Ligne]} {
if {[info exists XYZP]} {
lappend LesXYZP $XYZP
unset XYZP
}
}
if {[regexp {;} $Ligne]} { continue }
if {[regexp {\:=} $Ligne]} {
regsub {\:=} $Ligne " " Ligne
scan $Ligne "%s %s %s" Objet MotVec ItemOuDots
if { ! [regexp -nocase "vec" $MotVec]} {
FaireLire "$Ligne is wrong"
}
set Item [regexp -nocase "^item" $ItemOuDots]
set Dots [regexp -nocase "^dots" $ItemOuDots]
set XYZP {}
set y 0.0
continue
}
regsub -all {[\t\,]} $Ligne " " Ligne
set y [expr $y+1]
set z 0.0
scan $Ligne "%s %f %f %f" PL x y z
set PL [string tolower $PL]
if {$Item} {
lappend XYZP $z $y $x $PL
}
if {$Dots} {
lappend XYZP $x $y $z p
lappend XYZP $x $y $z l
}
}
return $LesXYZP
}
proc CouleurParTypeEtNom {TypeDeCouleur Nom K} {
global RepertoireDuGenome
global CouleurDuFond
global LesORFsEnOverlap
global CodonPreference CodonPreferenceMini CodonPreferenceMaxi
global CouleurDeFrame SignificationCouleurDeFrame
global CouleurDuCodonStart SignificationCouleurDuCodonStart
global CouleurFiabiliteFonction SignificationCouleurFiabiliteFonction
global CouleurDeLaSuperClasse SignificationCouleurDeLaSuperClasse
global TasTamis
if {[regexp "GLIMMER" $Nom]} { return $CouleurDuFond }
if { $TypeDeCouleur=="ClassesFonctionnelles" && ! [info exists CouleurDeLaSuperClasse]} {
set CouleurDeLaSuperClasse(Hy) "yellow"
set CouleurDeLaSuperClasse(NC) "green"
set CouleurDeLaSuperClasse(CP) "blue"
set CouleurDeLaSuperClasse(Tl) "orange"
set CouleurDeLaSuperClasse(RT) "red"
set CouleurDeLaSuperClasse(CE) "blue"
set CouleurDeLaSuperClasse(Me) "green"
set CouleurDeLaSuperClasse(tR) "black"
set CouleurDeLaSuperClasse(RR) "black"
set CouleurDeLaSuperClasse(IG) $CouleurDuFond
foreach {SC ValCouleurDeLaSuperClasse} [array get CouleurDeLaSuperClasse] {
if {[info exists SignificationCouleurDeLaSuperClasse($ValCouleurDeLaSuperClasse)]} {
append SignificationCouleurDeLaSuperClasse($ValCouleurDeLaSuperClasse) "or $SC"
} else {
set SignificationCouleurDeLaSuperClasse($ValCouleurDeLaSuperClasse) "SuperClass $SC"
}
}
}
if { $TypeDeCouleur=="FiabiliteFonction" && ! [info exists CouleurFiabiliteFonction]} {
set CouleurFiabiliteFonction(0) "white"
set CouleurFiabiliteFonction(1) "skyblue"
set CouleurFiabiliteFonction(2) "skyblue"
set CouleurFiabiliteFonction(3) "green"
set CouleurFiabiliteFonction(4) "green"
set CouleurFiabiliteFonction(5) "yellow"
set CouleurFiabiliteFonction(6) "yellow"
set CouleurFiabiliteFonction(7) "orange"
set CouleurFiabiliteFonction(8) "orange"
set CouleurFiabiliteFonction(9) "red"
set CouleurFiabiliteFonction(-1) "white"
}
if { $TypeDeCouleur=="SuivantLaFrame" && ! [info exists CouleurDeFrame] } {
set CouleurDeFrame(a) "blue"
set CouleurDeFrame(b) "white"
set CouleurDeFrame(c) "red"
set CouleurDeFrame(d) "yellow"
set CouleurDeFrame(e) "orange"
set CouleurDeFrame(f) "green"
set CouleurDeFrame(T) "brown"
set CouleurDeFrame(t) "brown"
set CouleurDeFrame(N) "purple"
set CouleurDeFrame(n) "purple"
set CouleurDeFrame(Z) "grey"
set CouleurDeFrame(z) "grey"
foreach {F ValCouleurDeFrame} [array get CouleurDeFrame] {
if {[info exists SignificationCouleurDeFrame($ValCouleurDeFrame)]} {
append SignificationCouleurDeFrame($ValCouleurDeFrame) "or $F"
} else {
set SignificationCouleurDeFrame($ValCouleurDeFrame) "Frame $F"
}
}
}
if { ! [info exists CouleurDuCodonStart]} {
set CouleurDuCodonStart(ATG) "green"
set CouleurDuCodonStart(GTG) "yellow"
set CouleurDuCodonStart(TTG) "orange"
set CouleurDuCodonStart(Anormal) "red"
set CouleurDuCodonStart(OK) "lightgreen"
set CouleurDuCodonStart(Probleme) "white"
set CouleurDuCodonStart(Inconnu) "grey"
foreach {CS ValCouleurDuCodonStart} [array get CouleurDuCodonStart] {
set SignificationCouleurDuCodonStart($ValCouleurDuCodonStart) "StartCodon $CS"
}
}
switch "Coloration_$TypeDeCouleur" {
"Coloration_WithXColumn" { # 1.0
if {[WithXColumn $Nom]} { set Couleur "green" } else { set Couleur "lightblue" }
SetSignification $K green "Contains a column of XMotif"
SetSignification $K lighblue "No full column"
}
"Coloration_XMotif" { # 1.0
set Couleur [HasXMotif $Nom Color]
SetSignification $K green "Contains XMotif"
SetSignification $K lighblue "No XMotif"
}
"Coloration_XMotif16S" { # 1.0
set Couleur [HasXMotif16S $Nom Color]
SetSignification $K green "Contains XMotif from ARN16S"
SetSignification $K lighblue "No XMotif from ARN16S"
}
"Coloration_Transcriptional_Units" { # 1.0
set Couleur [TU $Nom Color]
SetSignification $K color "According to Trandcriptional Units"
}
"Coloration_FromTamis" { # 9.99 noWeb
set Couleur "grey"
if {[info exists TasTamis($Nom)]} { set Couleur "green" }
if {[info exists TasTamis(FromTamis)]} {
SetSignification $K green "Ok in tamis [set TasTamis(FromTamis)]"
SetSignification $K grey "No in tamis [set TasTamis(FromTamis)]"
}
}
"Coloration_Taxonomy" { # 1.0 noWeb
set Couleur "white"
set Taxo [Taxonomy $Nom]
if {[regexp "Virus" $Taxo]} { set Couleur "darkgrey" ; SetSignification $K darkgrey "Virus"}
if {[regexp "Bacteria" $Taxo]} { set Couleur "yellow" ; SetSignification $K yellow "Bacteria"}
if {[regexp "Archae" $Taxo]} { set Couleur "blue" ; SetSignification $K blue "Archae"}
if {[regexp "Eukaryota" $Taxo]} { set Couleur "pink" ; SetSignification $K pink "Eukaryota"}
if {[regexp "Metazoa" $Taxo]} { set Couleur "red" ; SetSignification $K red "Metazoa"}
if {[regexp "Nematoda" $Taxo]} { set Couleur "orange" ; SetSignification $K orange "Nematoda"}
if {[regexp "Arthropoda" $Taxo]} { set Couleur "purple" ; SetSignification $K purple "Arthropoda"}
if {[regexp "sapiens" $Taxo]} { set Couleur "green" ; SetSignification $K green "Human"}
if {[regexp "musculus" $Taxo]} { set Couleur "cyan" ; SetSignification $K cyan "Mouse"}
if {[regexp "Xenopus" $Taxo]} { set Couleur "brown" ; SetSignification $K brown "Xenopus"}
if {[regexp "elegans" $Taxo]} { set Couleur "lightgreen" ; SetSignification $K lightgreen "C.elegans"}
}
"Coloration_Outlier" { # 1.1 Web
set Couleur "white"
set OutlierScore [OutlierScore $Nom]
scan $OutlierScore "%s" OutlierScore
if { $OutlierScore==""} { set OutlierScore -9 }
if { [expr $OutlierScore < -9 ] } { set Couleur "green" }
if { [expr -9 <= $OutlierScore] && [expr $OutlierScore < -1 ] } { set Couleur "yellow" }
if { [expr -1 <= $OutlierScore] && [expr $OutlierScore < 1 ] } { set Couleur "orange" }
if { [expr 1 <= $OutlierScore] && [expr $OutlierScore < 99 ] } { set Couleur "red" }
if { [expr 99 <= $OutlierScore] } { set Couleur "lightblue" }
SetSignification $K white "Not yet available"
SetSignification $K green "Outlier better at least e10"
SetSignification $K yellow "Outlier with equal expect"
SetSignification $K red "Reference better than Outlier"
SetSignification $K skyblue "No outlier or reference in the blast"
}
"Coloration_Balibase" { # 1.1 noWeb
set Couleur "white"
set Classe [ExtraitInfo $Nom "RV"]
if {[regexp "11" $Classe]} { set Couleur "red" }
if {[regexp "12" $Classe]} { set Couleur "orange" }
if {[regexp "20" $Classe]} { set Couleur "yellow" }
if {[regexp "30" $Classe]} { set Couleur "skyblue" }
if {[regexp "40" $Classe]} { set Couleur "blue" }
if {[regexp "50" $Classe]} { set Couleur "purple" }
SetSignification $K red "Class Ref1v1"
SetSignification $K orange "Class Ref1v2"
SetSignification $K yellow "Class Ref2"
SetSignification $K skyblue "Class Ref3"
SetSignification $K blue "Class Ref4"
SetSignification $K purple "Class Ref5"
}
"Coloration_CheckCompletion" { # 1.1 noWeb
set Couleur [CheckCompletion $Nom Color]
SetSignification $K $Couleur [GeneEtendu $Nom Signification]
}
"Coloration_Rejected" { # 1.1 noWeb
set Couleur "white"
set Reject [ExtraitInfo $Nom "Rejected:"]
if {$Reject!=""} { set Couleur "green" }
if {[regexp "NoRejected" $Reject]} { set Couleur "red" }
SetSignification $K red "NoRejected"
SetSignification $K green "Rejected"
SetSignification $K green "Not yet annotated"
}
"Coloration_ScerevisiaeEhistolica" { # 1.1 noWeb
set Couleur "green"
set Sc [ExtraitInfo $Nom "Reciproc1_blastpSc:"]
set Eh [ExtraitInfo $Nom "Reciproc1_blastpEhistolica:"]
if { [regexp "^No" $Sc] && [regexp "^No" $Eh]} { set Couleur "yellow" }
if { [regexp "^No" $Sc] && ! [regexp "^No" $Eh]} { set Couleur "blue" }
if { ! [regexp "^No" $Sc] && [regexp "^No" $Eh]} { set Couleur "red" }
if { ! [regexp "^No" $Sc] && ! [regexp "^No" $Eh]} { set Couleur "green" }
SetSignification $K yellow "-Sc -Eh"
SetSignification $K blue "-Sc +Eh"
SetSignification $K red "+Sc -Eh"
SetSignification $K green "+Sc +Eh"
}
"Coloration_ScerevisiaeTbrucei" { # 1.1 noWeb
set Couleur "green"
set Sc [ExtraitInfo $Nom "Reciproc1_blastpSc:"]
set Tb [ExtraitInfo $Nom "Reciproc_blastpTbrucei:"]
if { [regexp "^No" $Sc] && [regexp "^No" $Tb]} { set Couleur "yellow" }
if { [regexp "^No" $Sc] && ! [regexp "^No" $Tb]} { set Couleur "blue" }
if { ! [regexp "^No" $Sc] && [regexp "^No" $Tb]} { set Couleur "red" }
if { ! [regexp "^No" $Sc] && ! [regexp "^No" $Tb]} { set Couleur "green" }
SetSignification $K yellow "-Sc -Tb"
SetSignification $K blue "-Sc +Tb"
SetSignification $K red "+Sc -Tb"
SetSignification $K green "+Sc +Tb"
}
"Coloration_ScerevisiaePfalciparum" { # 1.1 noWeb
set Couleur "green"
set Sc [ExtraitInfo $Nom "Reciproc1_blastpSc:"]
set Pf [ExtraitInfo $Nom "Reciproc_blastpPfalciparum:"]
if { [regexp "^No" $Sc] && [regexp "^No" $Pf]} { set Couleur "yellow" }
if { [regexp "^No" $Sc] && ! [regexp "^No" $Pf]} { set Couleur "blue" }
if { ! [regexp "^No" $Sc] && [regexp "^No" $Pf]} { set Couleur "red" }
if { ! [regexp "^No" $Sc] && ! [regexp "^No" $Pf]} { set Couleur "green" }
SetSignification $K yellow "-Sc -Pf"
SetSignification $K blue "-Sc +Pf"
SetSignification $K red "+Sc -Pf"
SetSignification $K green "+Sc +Pf"
}
"Coloration_ReciprocTbrucei" { # 1.1 noWeb
set Couleur "green"
set Reciproc [ExtraitInfo $Nom "Reciproc_blastpTbrucei:"]
if {[regexp "NoBlastFile" $Reciproc]} { set Couleur "white" }
if {[regexp "NoHitFound" $Reciproc]} { set Couleur "grey" }
if {[regexp "NoSequenceFor" $Reciproc]} { set Couleur "lightgrey" }
if {[regexp "NoBlastResultFor" $Reciproc]} { set Couleur "orange" }
if {[regexp "NoReciprocalHitFor" $Reciproc]} { set Couleur "red" }
SetSignification $K green "ReciprocExists"
SetSignification $K white "NoBlastFile"
SetSignification $K grey "NoHitFound"
SetSignification $K lightgrey "NoSequenceFor"
SetSignification $K orange "NoBlastResultFor"
SetSignification $K red "NoReciprocalHitFor"
}
"Coloration_ReciprocPfalciparum" { # 1.1 noWeb
set Couleur "green"
set Reciproc [ExtraitInfo $Nom "Reciproc_blastpPfalciparum:"]
if {[regexp "NoBlastFile" $Reciproc]} { set Couleur "white" }
if {[regexp "NoHitFound" $Reciproc]} { set Couleur "grey" }
if {[regexp "NoSequenceFor" $Reciproc]} { set Couleur "lightgrey" }
if {[regexp "NoBlastResultFor" $Reciproc]} { set Couleur "orange" }
if {[regexp "NoReciprocalHitFor" $Reciproc]} { set Couleur "red" }
SetSignification $K green "ReciprocExists"
SetSignification $K white "NoBlastFile"
SetSignification $K grey "NoHitFound"
SetSignification $K lightgrey "NoSequenceFor"
SetSignification $K orange "NoBlastResultFor"
SetSignification $K red "NoReciprocalHitFor"
}
"Coloration_Famille" { # 1.1 noWeb
set Couleur "white"
set Famille [ExtraitInfo $Nom "Famille:"]
if {[regexp "P62" $Famille]} { set Couleur "green" }
if {[regexp "DOS" $Famille]} { set Couleur "yellow" }
if {[regexp "SAP" $Famille]} { set Couleur "red" }
if {[regexp "Other" $Famille]} { set Couleur "grey" }
SetSignification $K green "Famille P62"
SetSignification $K yellow "Famille DOS"
SetSignification $K red "Famille SAP"
SetSignification $K grey "Famille Other"
}
"Coloration_Classes" { # 1.1 noWeb
set Couleur "white"
set Classe [ExtraitInfo $Nom "Class"]
if {[regexp "1a" $Classe]} { set Couleur "red" }
if {[regexp "1b" $Classe]} { set Couleur "orange" }
if {[regexp "1c" $Classe]} { set Couleur "yellow" }
if {[regexp "2a" $Classe]} { set Couleur "skyblue" }
if {[regexp "2b" $Classe]} { set Couleur "blue" }
if {[regexp "2c" $Classe]} { set Couleur "purple" }
SetSignification $K red "Class 1a"
SetSignification $K orange "Class 1b"
SetSignification $K yellow "Class 1c"
SetSignification $K skyblue "Class 2a"
SetSignification $K blue "Class 2b"
SetSignification $K purple "Class 2c"
}
"NoColoration_ContigsAlternes" { # 1.2 noWeb
set Couleur "grey"
scan [ContigDuPAB $Nom] "%s" Contig
if {[regexp {[02468]$} $Contig]} { set Couleur "white" }
if {[regexp {[13579]$} $Contig]} { set Couleur "black" }
SetSignification $K white "Contig even"
SetSignification $K black "Contig odd"
SetSignification $K grey "Contig unknown"
}
"Coloration_DifferentialDisplay" { # 1.8 noWeb
set Couleur [DifferentialDisplay $Nom Color]
SetSignification $K $Couleur [DifferentialDisplay $Nom Signification]
}
"Coloration_GeneEtendu" { # 2.1 noWeb
set Couleur [GeneEtendu $Nom Color]
SetSignification $K $Couleur [GeneEtendu $Nom Signification]
}
"Coloration_SuivantLaFrame" { # 2.2
set Couleur [set CouleurDeFrame([Box $Nom frame])]
SetSignification $K $Couleur [set SignificationCouleurDeFrame($Couleur)]
}
"Coloration_CodonStartMVL" { # 2.3
if {[info exists CouleurDuCodonStart([NucDuCodonStart $Nom])]} {
set Couleur $CouleurDuCodonStart([NucDuCodonStart $Nom])
} else {
Warne "Codon anormal en $Nom"
set Couleur $CouleurDuCodonStart(Anormal)
}
SetSignification $K $Couleur [set SignificationCouleurDuCodonStart($Couleur)]
}
"Coloration_BiaisEnGC" { # 2.4
set GC [CompositionEn GC $Nom]
if { $GC == "" } {
set Couleur "white"
SetSignification $K $Couleur "GC skew no value"
} else {
set Couleur [QuelInterval $GC [LesSeuilsGC] [CouleursDuRougeAuBleu 5]]
set Signif [QuelInterval $GC [LesSeuilsGC] [LesSeuilsGC "SignificationMerci"]]
SetSignification $K $Couleur $Signif
}
}
"Coloration_Overlap" { # 2.5
if { [Fantome $Nom] } {
set Couleur $CouleurDuFond
SetSignification $K $Couleur "Overlap Fantome"
} else {
set Couleur "green"
SetSignification $K $Couleur "No overlap"
set Olap [Overlap $Nom]
regsub -all {Overlap\: *} $Olap "/" Olap
if { $Olap != "" && $Olap != "/" } {
if {[regexp "I begin" $Olap]} {
set Couleur "red"
SetSignification $K $Couleur "Overlap of more than 4 bases"
}
if {[regexp "/1 bases. I begin" $Olap]} {
set Couleur "orange"
SetSignification $K $Couleur "Overlap 1 base (as taAtg or tgAtg or taGtg)"
}
if {[regexp "/4 bases. I begin" $Olap]} {
set Couleur "yellow"
SetSignification $K $Couleur "Overlap 4 bases (as aTGa or gTGa or tTGa)"
}
if {[regexp "I am in" $Olap]} {
set Couleur "blue"
SetSignification $K $Couleur "Full overlaped"
}
}
}
}
"Coloration_ShineDalgarno" { # 2.6
switch -regexp [ShineDalgarno $Nom] {
"^bons" {
set Couleur "green"
SetSignification $K $Couleur "With ShineDalgarno"
}
"^mets" {
set Couleur "yellow"
SetSignification $K $Couleur "ShineDalgarno if you change StartCodon"
}
"^loin" {
set Couleur "orange"
SetSignification $K $Couleur "Far ShineDalgarno"
}
"^sans" {
set Couleur "red"
SetSignification $K $Couleur "NoShineDalgarno"
}
default { set Couleur $CouleurDuFond }
}
}
"NoColoration_CodonPreference" {
if { ! [info exists CodonPreference] } { ChargeCodonPreference }
if { ! [info exists CodonPreference($Nom)] } {
set Couleur $CouleurDuFond
SetSignification $K $Couleur "CodonPreference no value"
} else {
set Preference [set CodonPreference($Nom)]
set ValeurEntre0et1 [expr ($Preference-$CodonPreferenceMini) / ($CodonPreferenceMaxi-$CodonPreferenceMini)]
set Couleur [Nuance $ValeurEntre0et1]
}
SetSignification $K $Couleur "CodonPreference [setCodonPreference($Nom)]"
}
"NoColoration_TrogStatus" {
set Couleur "grey"
set Status [TrogStatus $Nom]
if {[regexp -- "^0" $Status]} { set Couleur "red" }
if {[regexp -- "^1" $Status]} { set Couleur "yellow" }
if {[regexp -- "^2" $Status]} { set Couleur "green" }
if {[regexp -- "-1" $Status]} { set Couleur "grey" }
SetSignification $K red "TrogStatus Loss"
SetSignification $K yellow "TrogStatus FalseOrthologue"
SetSignification $K green "TrogStatus TrueOrthologue"
SetSignification $K grey "TrogStatus NoOrthologue"
}
"Coloration_RepeatMasker" { # 3.2 noWeb
set Couleur [QuelMask $Nom "ColorPlease"]
SetSignification $K $Couleur [QuelMask $Nom]
}
"Coloration_RepeatMRM" { # 3.21 noWeb
set Couleur [QuelMaskMRM $Nom "ColorPlease"]
SetSignification $K $Couleur [QuelMaskMRM $Nom]
}
"Coloration_PolyLocalization" { # 3.5 noWeb
set Couleur [PolyLocalise $Nom "ColorPlease"]
SetSignification $K $Couleur [PolyLocalise $Nom]
}
"Coloration_OverlapAffymetrix" { # 3.6 noWeb
if {[WithOverlapAffymetrix $Nom]} {
set Couleur "green"
SetSignification $K $Couleur "Affymetrix overlap"
} else {
set Couleur "grey"
SetSignification $K $Couleur "No Affymetrix overlap"
}
}
"Coloration_CompareSeqWithQuery" { # 3.7
set FichierTFA "[RepertoireDuGenome]/prottfa/$Nom"
set AutreRep "[RepertoireDuGenome]/prottfainitial"
set MS [MemesSequencesDansFichiersTFA $FichierTFA $AutreRep "Pourquoi"]
set Couleur "black"
regexp {\(([a-z]+)\)} $MS Match Couleur
SetSignification $K $Couleur "$MS"
}
"Coloration_NombreDeCopainsDansBlast" { # 4.1
CouleurAuNombreDeCopainsDansBlast SetAllSignification $K
set Couleur [CouleurAuNombreDeCopainsDansBlast [NombreDeCopainsDansBlast $Nom]]
}
"Coloration_HitMultiple" { # 4.2
set HitMultiple [HitMultiple $Nom]
if {$HitMultiple=={}} {
set Couleur "green"
SetSignification $K "green" "No Multiple Hit"
} else {
if {[regexp "FS no" [ExtraitInfo $Nom "EP"]]} {
set Couleur "yellow"
SetSignification $K "yellow" "With Multiple Hit without Frameshift"
} else {
set Couleur "red"
SetSignification $K "red" "With Multiple Hit and Frameshift"
}
}
}
"Coloration_PDBstructures" { # 4.3
set Couleur "white"
set n [WithPDB $Nom]
if {29 < $n } { set Couleur "red" }
if { 9 < $n && $n <= 29 } { set Couleur "orange" }
if { 5 < $n && $n <= 9 } { set Couleur "yellow" }
if { 1 < $n && $n <= 5 } { set Couleur "green" }
if { 0 < $n && $n <= 1 } { set Couleur "blue" }
if { $n <= 0 } { set Couleur "grey" }
SetSignification $K red "known PDB structures 29 < n"
SetSignification $K orange "known PDB structures 9 < n && n <= 29 "
SetSignification $K yellow "known PDB structures 5 < n && n <= 9 "
SetSignification $K green "known PDB structures 1 < n && n <= 5 "
SetSignification $K blue "known PDB structures 0 < n && n <= 1 "
SetSignification $K grey "known PDB structures n == 0 "
SetSignification $K white "known PDB structures no value"
}
"Coloration_PDBDansGroupes" { # 4.3
set Couleur [NombreDePDBDansGroupes $Nom "couleur"]
SetSignification $K $Couleur [NombreDePDBDansGroupes $Nom "signification"]
}
"Coloration_NumberOfParalogues" { # 4.8
set nPara [llength [ParaloguesDe $Nom]]
if {$nPara<=0} {
set Couleur "blue"
SetSignification $K $Couleur "$nPara paralogues"
} elseif {$nPara==1} {
set Couleur "yellow"
SetSignification $K $Couleur "$nPara paralogues"
} elseif {$nPara<=3} {
set Couleur "green"
SetSignification $K $Couleur "2 <= nParalogues <= 3"
} elseif {$nPara<=8} {
set Couleur "orange"
SetSignification $K $Couleur "4 <= nParalogues <= 8"
} else {
set Couleur "red"
SetSignification $K $Couleur "9 <= nParalogues"
}
}
"Coloration_ProttfaFileExists" { # 4.9
set TheRep "prottfa"
if {[file exists "$RepertoireDuGenome/$TheRep/$Nom"]} {
set Couleur "green"
SetSignification $K $Couleur "file exists in $TheRep"
} else {
set Couleur "red"
SetSignification $K $Couleur "file does not exist in $TheRep"
}
}
"Coloration_MSFParaloguesExiste" { # 4.9
if {[file exists "$RepertoireDuGenome/msfparalogues/$Nom"]} {
set Couleur "green"
SetSignification $K $Couleur "Paralog exist"
} else {
set Couleur "blue"
SetSignification $K $Couleur "Paralog no"
}
}
"Coloration_AnchorsCount" { # 5.1 noWeb
set AC [AnchorsCount $Nom]
set AC "$AC.0"
set Couleur [QuelInterval $AC [LesSeuilsAC] [LesSeuilsAC "CouleurMerci"]]
set Signif [QuelInterval $AC [LesSeuilsAC] [LesSeuilsAC "SignificationMerci"]]
SetSignification $K $Couleur $Signif
}
"Coloration_MDScore" { # 5.1
set MD [MDScore $Nom]
set Couleur [QuelInterval $MD [LesSeuilsMDScore] [LesSeuilsMDScore "CouleurMerci"]]
set Signif [QuelInterval $MD [LesSeuilsMDScore] [LesSeuilsMDScore "SignificationMerci"]]
SetSignification $K $Couleur $Signif
}
"Coloration_WithKegg" { # 5.9
if {[AvecKegg $Nom]=="Yes"} {
set Couleur "green"
SetSignification $K $Couleur "Kegg information is available"
}
if {[AvecKegg $Nom]=="Nothing"} {
set Couleur "red"
SetSignification $K $Couleur "No Kegg was found"
}
if {[AvecKegg $Nom]=="NotAvailable"} {
set Couleur "grey"
SetSignification $K $Couleur "No Kegg not yet processed"
}
}
"Coloration_HomologDetectionAgreement" { # 6.1
set Couleur [HomologDetectionAgreement $Nom "Color"]
SetSignification $K $Couleur [HomologDetectionAgreement $Nom "Signif"]
}
"Coloration_PresenceAndAbsenceMSF" { # 6.2
if {[PresenceEtAbsenceDesGenomesComplets $Nom "MSF"]} {
set Couleur "green"
SetSignification $K $Couleur "Present"
} else {
set Couleur "grey"
SetSignification $K $Couleur "Absent"
}
}
"Coloration_PresenceAndAbsenceBlastP" { # 6.3
if {[PresenceEtAbsenceDesGenomesComplets $Nom "BlastP"]} {
set Couleur "green"
SetSignification $K $Couleur "Present"
} else {
set Couleur "grey"
SetSignification $K $Couleur "Absent"
}
}
"Coloration_PresenceAndAbsenceTBlastN" { # 6.4
if {[PresenceEtAbsenceDesGenomesComplets $Nom "TBlastN"]} {
set Couleur "green"
SetSignification $K $Couleur "Present"
} else {
set Couleur "grey"
SetSignification $K $Couleur "Absent"
}
}
"Coloration_TaxoSpecif" { # 6.45
set Couleur [TaxoSpecif $Nom "color"]
SetSignification $K $Couleur [TaxoSpecif $Nom "signification"]
}
"Coloration_SameClusterXHda" { # 6.5 noWeb
set Couleur [ColorationDesClustersXHdaDesNomsPiques $Nom "Couleur"]
SetSignification $K $Couleur [ColorationDesClustersXHdaDesNomsPiques $Nom "Signif"]
}
"Coloration_PhylumOrtho" { # 6.6
set Couleur "lightgrey"
set BAE [PhylumsOrthologues $Nom]
if {[regexp "BAE" $BAE]} { set Couleur "white" }
if {[regexp "BAe" $BAE]} { set Couleur "green" }
if {[regexp "BaE" $BAE]} { set Couleur "orange" }
if {[regexp "Bae" $BAE]} { set Couleur "yellow" }
if {[regexp "bAE" $BAE]} { set Couleur "purple" }
if {[regexp "bAe" $BAE]} { set Couleur "blue" }
if {[regexp "baE" $BAE]} { set Couleur "red" }
if {[regexp "bae" $BAE]} { set Couleur "grey" }
SetSignification $K white "BAE high all phylums"
SetSignification $K green "BAe low Eukaryota"
SetSignification $K orange "BaE low Archaea"
SetSignification $K yellow "Bae Bacteria"
SetSignification $K purple "bAE low Bacteria"
SetSignification $K blue "bAe high Archaea"
SetSignification $K red "baE high Eukariota"
SetSignification $K grey "bae low all phylums"
SetSignification $K lightgrey "bae no value"
}
"Coloration_NearestOrganismsHit" { # 6.5
set Couleur "lightgrey"
set NOH [NearestOrganismsHit $Nom]
if {$NOH==0} { set Couleur "red" }
if {$NOH==1} { set Couleur "green" }
if {$NOH==2} { set Couleur "blue" }
SetSignification $K green "Hit in nearest organisms"
SetSignification $K red "No hit found in nearest organisms"
SetSignification $K blue "No hit at all"
SetSignification $K lightgrey "No value"
}
"Coloration_OperonsHomologues" { # 6.5
set N [CompteDesOrganismesAyantMemeOperon $Nom]
if { $N == 0 } {
set Couleur "grey"
SetSignification $K $Couleur "ClusterMaintenance Zero"
} else {
set Couleur [QuelInterval $N [LesSeuilsOperonsHomologues] [CouleursDuBleuAuRouge 5]]
set Signif [QuelInterval $N [LesSeuilsOperonsHomologues] [LesSeuilsOperonsHomologues "SignificationMerci"]]
SetSignification $K $Couleur $Signif
}
}
"Coloration_DeletedStart" { # 7.1 noWeb
if {[DeletedStart $Nom]} {
set Couleur "red"
SetSignification $K $Couleur "PossibleDeletedStart"
} else {
set Couleur "green"
SetSignification $K $Couleur "No information about start"
}
}
"Coloration_CodonStartOK" { # 7.1 noWeb
set Couleur $CouleurDuCodonStart(Inconnu)
if {[regexp -nocase "OK" [CodonStart $Nom]] } {
set Couleur $CouleurDuCodonStart(OK)
}
if {[regexp -nocase "Problem" [CodonStart $Nom]] } {
set Couleur $CouleurDuCodonStart(Probleme)
}
SetSignification $K $Couleur [set SignificationCouleurDuCodonStart($Couleur)]
}
"Coloration_StartCodonColor" { # 7.1
set Couleur [StartCodonReport $Nom "Couleur"]
SetSignification $K $Couleur [StartCodonReport $Nom "Signification"]
}
"Coloration_DiffBlaAli" { # 7.2
set Couleur "white"
set DBA [DiffBlaAli $Nom]
if {[regexp "^No" $DBA]} { set Couleur "grey" }
if {[regexp "^Same" $DBA]} { set Couleur "green" }
if {[regexp "^Close" $DBA]} { set Couleur "orange" }
if {[regexp "^Different" $DBA]} { set Couleur "red" }
SetSignification $K red "Blast vs DbClustal Different"
SetSignification $K orange "Blast vs DbClustal Close"
SetSignification $K green "Blast vs DbClustal same"
SetSignification $K grey "Blast vs DbClustal no alignment"
SetSignification $K white "Blast vs DbClustal no value"
}
"Coloration_Target" { # 7.3
set Target [ExtraitInfo $Nom "Target"]
if {$Target==""} {
set Couleur "grey"
SetSignification $K $Couleur "No Target information available"
} else {
if {[regexp -nocase "OK" $Target]} {
set Couleur "green"
SetSignification $K $Couleur "Target OK"
} else {
set Couleur "lightblue"
SetSignification $K $Couleur "not selected as target"
}
}
}
"Coloration_CAIecol" { # 7.3
set x [CAI $Nom]
if { $x == "" } {
set Couleur "white"
SetSignification $K $Couleur "CAI no value"
} else {
set Couleur [QuelInterval $x [LesSeuilsCAI] [CouleursDuRougeAuBleu 5]]
set Signif [QuelInterval $x [LesSeuilsCAI] [LesSeuilsCAI "SignificationMerci"]]
SetSignification $K $Couleur $Signif
}
}
"Coloration_HydrophobicIndex" { # 7.4
set Couleur "white"
set H [Hydrophobicity $Nom "Hydro"]
if { $H <= 0.85 } { set Couleur "yellow" }
if { 0.85 < $H } { set Couleur "blue" }
SetSignification $K yellow "HydrophobicIndex less than 0.85"
SetSignification $K blue "HydrophobicIndex more than 0.85"
SetSignification $K white "HydrophobicIndex no value"
}
"Coloration_HydrophobicHelices" { # 7.5
set Couleur "white"
set nH [Hydrophobicity $Nom "nHelices"]
if { $nH > 7 } { set Couleur "red" }
if { $nH == 7 } { set Couleur "orange" }
if { $nH == 6 } { set Couleur "yellow" }
if { $nH == 5 } { set Couleur "yellow" }
if { $nH == 4 } { set Couleur "green" }
if { $nH == 3 } { set Couleur "skyblue" }
if { $nH == 2 } { set Couleur "skyblue" }
if { $nH == 1 } { set Couleur "skyblue" }
if { $nH == 0 } { set Couleur "blue" }
SetSignification $K red "HydrophobicHelices 8, and more"
SetSignification $K orange "HydrophobicHelices 7"
SetSignification $K yellow "HydrophobicHelices 5, 6"
SetSignification $K green "HydrophobicHelices 4"
SetSignification $K skyblue "HydrophobicHelices 1, 2, 3"
SetSignification $K blue "HydrophobicHelices 0"
SetSignification $K white "HydrophobicHelices no value"
}
"Coloration_FiabiliteFonction" { # 9.7 noWeb
set FF [FiabiliteFonction $Nom]
if { ! [regexp {[0-9]} $FF] } {
set Couleur [set CouleurFiabiliteFonction(-1)]
SetSignification $K $Couleur "Function reliability bad value"
} else {
scan $FF "%d" Valeur
if { [info exists Valeur] && \
[info exists CouleurFiabiliteFonction($Valeur)] } {
set Couleur [set CouleurFiabiliteFonction($Valeur)]
SetSignification $K $Couleur "Function reliability $FF"
} else {
Warne "Code FiabiliteFonction $FF pour $Nom incomprehensible"
set Couleur [set CouleurFiabiliteFonction(-1)]
SetSignification $K $Couleur "Function reliability bad value"
}
}
}
"NoColoration_LesCas" {
if {[Fantome $Nom]} {
set Couleur $CouleurDuFond
} elseif {[regexp "CasNonConnu" [Cas $Nom]]} {
set Couleur "white"
} elseif {[regexp {^1} [Cas $Nom]]} {
set Couleur "black"
} elseif {[regexp {1$} [Cas $Nom]]} {
set Couleur "red"
} elseif {[regexp {1,0$} [Cas $Nom]]} {
set Couleur "orange"
} elseif {[regexp {1,0,0$} [Cas $Nom]]} {
set Couleur "yellow"
} else {
set Couleur "green"
}
}
"Coloration_PhyloFolle" { # 6.8 noWeb
if {[Fantome $Nom]} {
set Couleur $CouleurDuFond
SetSignification $K $Couleur "no Phylo : Fantome"
} elseif {[PhyloFolle $Nom] == 1} {
set Couleur "red"
SetSignification $K $Couleur "Phylo crazy"
} elseif {[PhyloFolle $Nom] == -1} {
set Couleur "white"
SetSignification $K $Couleur "Phylo no value"
} else {
set Couleur "green"
SetSignification $K $Couleur "Phylo normal"
}
}
"Coloration_ClassesFonctionnelles" { # 9.9 noWeb
set SC [SuperClasse [ClasseFonctionnelle $Nom]]
if {[info exists CouleurDeLaSuperClasse($SC)]} {
set Couleur [set CouleurDeLaSuperClasse($SC)]
SetSignification $K $Couleur "Functional class $SC"
} else {
set Couleur $CouleurDuFond
SetSignification $K $Couleur "Functional class no value"
}
}
"NoColoration_InfoExiste" { # 9.3 noWeb
if { [file exists "$RepertoireDuGenome/infos/$Nom"] } {
if {[regexp "[PreFixe]" $Nom]} {
set Couleur "skyblue"
SetSignification $K $Couleur "Info file exists for this [PreFixe]"
} else {
switch -regexp $Nom {
"TROU" {
set Couleur "grey"
SetSignification $K $Couleur "Info file exists for this InterGenicRegion"
}
"TRNA" {
set Couleur "purple"
SetSignification $K $Couleur "Info file exists for this TRNA"
}
"ARN" {
set Couleur "brown"
SetSignification $K $Couleur "Info file exists for this ARN"
}
default {
FaireLire "pas de couleur affectee a $Nom InfoExiste"
}
}
}
} else {
set Couleur "red"
SetSignification $K $Couleur "Info file does'nt exists."
}
}
default {
set Couleur "black"
}
}
return $Couleur
}
proc PiqueArc {K X Y {Efface ""}} {
global RepertoireDuGenome
set x [$K canvasx $X]
set y [$K canvasy $Y]
set Id [$K find withtag current]
set SesTags [$K gettags $Id]
if { [lindex $SesTags 0] != "Arc" } { return }
set Nom [lindex [split [lindex $SesTags 1] "/"] 0]
set Voisin [lindex [split [lindex $SesTags 1] "/"] 1]
# set Texte [TexteOMO $Nom "Long"]
set Texte " Operons: [ORGAorgaDesOperons $Nom Stars]"
append Texte "\n[ORGAorgaDesOperons $Nom Names]"
regsub ".canvas" $K ".message" M
catch {destroy $M}
if {$Efface!=""} {
return ""
}
message $M -borderwidth 3 -font {Courier 8} -relief raise -width 800 -text $Texte -background "lightyellow" -foreground "black"
place $M -x 10 -y [expr $y-40] -anchor w
return $M
}
proc NomDeScene Nom {
set Numero [NumeroDu $Nom]
if {[OnTraite "Topos"]} {
set Alias [ExtraitInfo $Nom "Alias"]
if {$Alias!=""} { return $Numero/$Alias }
}
set ValiGN [ExtraitInfo $Nom "ValiGN"]
if {$ValiGN != "" } {
if {[regexp -nocase {^(ncRNA|rRNA|tRNA)} $Nom]} { return "$Nom/$ValiGN" }
return "$Numero/$ValiGN"
}
if {[OnTraiteDesCDNAs]} {
set CC [CodeClone $Nom]
if {[OnTraiteDesAffymetrix]} {
set GN $CC
} else {
set OwnerOfCDNA [OwnerOfCDNA $Nom]
if {$OwnerOfCDNA!=""} { set OwnerOfCDNA "${OwnerOfCDNA}_" }
set GN "${OwnerOfCDNA}$CC"
}
if {$GN!=""} {return "$Numero/$GN" }
}
if {[OnTraiteUneCollection]} {
set Alias [Alias $Nom]
if {$Alias!=""} { return "$Numero/$Alias" }
if {[OnTraiteSpine]} {
set SpineID [SpineID $Nom]
if {$SpineID!=""} { return "$Numero/$SpineID" }
}
}
set GN_Narcisse [ExtraitInfo $Nom "GN_Narcisse"]
if {$GN_Narcisse!=""} {
regsub -nocase { or .*} $GN_Narcisse "" GN_Narcisse
return "$Numero/$GN_Narcisse"
}
return "$Nom"
}
proc SignificationLingeFrameFard K {
global TypeCouleur
global TypeFard
global TypeCouleurDuLinge
global TypeFardDuLinge
set U 15
if {[info exists TypeCouleurDuLinge($K)]} {
set TypeC [lindex [LaTraduction [list [set TypeCouleurDuLinge($K)]]] 0]
set Linge "Banner : $TypeC"
set Signif ""
set KLinge "${K}_Linge"
foreach S [GetSignification "ToutesLesCouleursPossibles" $KLinge] {
set Sppp [string range " $S [string repeat "_" $U]" 0 $U]
append Signif "\n$Sppp [GetSignification $S $KLinge]"
}
append Linge "\n$Signif"
} else {
set Linge "No color for the banner"
}
if {[info exists TypeCouleur($K)]} {
set TypeC [lindex [LaTraduction [list [set TypeCouleur($K)]]] 0]
set Frames "ORFs : $TypeC"
set Signif ""
foreach S [GetSignification "ToutesLesCouleursPossibles" $K] {
set Sppp [string range " $S [string repeat "_" $U]" 0 $U]
append Signif "\n$Sppp [GetSignification $S $K]"
}
append Frames "\n$Signif"
} else {
set Frames "No color for ORFs"
}
if {[info exists TypeFard($K)]} {
set TypeC [lindex [LaTraduction [list [set TypeFard($K)]]] 0]
set Fard "Highlight color : $TypeC"
} else {
set Fard "No highlight color"
}
return "$Linge\n\n\n$Frames\n\n\n$Fard"
}
proc NomDeLaFrame {A Orient} {
global NomDesFrames
if { ! [info exists NomDesFrames]} {
set NomDesFrames(0,F) "c"
set NomDesFrames(1,F) "a"
set NomDesFrames(2,F) "b"
set NomDesFrames(0,R) "d"
set NomDesFrames(1,R) "e"
set NomDesFrames(2,R) "f"
set NomDesFrames(TRNA,F) "T"
set NomDesFrames(TRNA,R) "t"
set NomDesFrames(ARN,F) "N"
set NomDesFrames(ARN,R) "n"
set NomDesFrames(TROU,F) "Z"
set NomDesFrames(TROU,R) "z"
}
return [set NomDesFrames($A,$Orient)]
}
proc CompositionEn {Type Nom} {
global RepertoireDuGenome
global CompositionEnATGC
if { ! [info exists CompositionEnATGC]} {
set FichierCompositionEnATGC "$RepertoireDuGenome/fiches/compositionenatgc"
if { [file exists $FichierCompositionEnATGC] } {
foreach Ligne [LesLignesDuFichier $FichierCompositionEnATGC] {
scan $Ligne "%s %d %d %d %d %d %d" NomLu pGC pAT pA pT pG pC
set CompositionEnATGC($NomLu) "$pGC $pAT $pA $pT $pG $pC"
lappend CompositionEnATGC(GC,LaListe) $pGC
lappend CompositionEnATGC(AT,LaListe) $pAT
lappend CompositionEnATGC(A,LaListe) $pA
lappend CompositionEnATGC(T,LaListe) $pT
lappend CompositionEnATGC(G,LaListe) $pG
lappend CompositionEnATGC(C,LaListe) $pC
}
}
set CompositionEnATGC(Bidon) "EstCharge"
}
if {$Nom=="LaListeMerci"} {
if {[info exists CompositionEnATGC($Type,LaListe)]} {
return [set CompositionEnATGC($Type,LaListe)]
} else {
return {}
}
}
if { ! [info exists CompositionEnATGC($Nom)]} { return "" }
scan [set CompositionEnATGC($Nom)] "%d %d %d %d %d %d" pGC pAT pA pT pG pC
if {$Type=="ATGC"} { return [set CompositionEnATGC($Nom)] }
return [set p$Type]
}
proc CreeLeFichierCompositionEnATGC {} {
global RepertoireDuGenome
global ListeDeBoites
if { ! [info exists ListeDeBoites]} { ChargeListeDeBoites }
set Source "BoutADN"
while { ! [BoutADN Existe]} {
if {[OuiOuNonMemo "Do I use the [RepertoireDuGenome]/nuctfa files to calculate ATGC composition ?"]} {
set Source "[RepertoireDuGenome]/nuctfa"
break
}
if {[OuiOuNonMemo "Do You want to browse a directory containing the nuc files ?"]} {
set Source [tk_chooseDirectory -mustexist 1 -initialdir "$RepertoireDuGenome/"]
if {$Source==""} { continue }
break
}
if {[OuiOuNon "DO You want to calculate ATGC composition later ?"]} { return "" }
}
set ntA 0
set ntT 0
set ntG 0
set ntC 0
set lt 0
foreach Boite $ListeDeBoites {
set Nom [Box $Boite nom]
if {$Source=="BoutADN"} {
set Debut [Box $Boite debut]
set Fin [Box $Boite fin]
set Orient [Box $Boite orient]
set ATGC [BoutADN $Debut $Fin $Orient]
} else {
set FichierNucTFA "$Source/$Nom"
if { ! [file exists $FichierNucTFA]} {
set ATGC ""
} else {
set ATGC [QueLaSequenceDuFichierTFA $FichierNucTFA]
}
}
set l [Maxi 1 [string length $ATGC]]
set nA 0
set nT 0
set nG 0
set nC 0
for {set i 0} {$i<$l} {incr i} {
incr lt
set c [string index $ATGC $i]
if { $c == "A" } { incr nA ; incr ntA }
if { $c == "T" } { incr nT ; incr ntT }
if { $c == "G" } { incr nG ; incr ntG }
if { $c == "C" } { incr nC ; incr ntC }
}
lappend Liste "$Nom \
[expr round(($nG+$nC)*100./$l)] \
[expr round(($nA+$nT)*100./$l)] \
[expr round(($nA) *100./$l)] \
[expr round(($nT) *100./$l)] \
[expr round(($nG) *100./$l)] \
[expr round(($nC) *100./$l)]"
}
set lt [Maxi $lt 1]
set Liste [linsert $Liste 0 "AllORFs \
[expr round(($ntG+$ntC)*100./$lt)] \
[expr round(($ntA+$ntT)*100./$lt)] \
[expr round(($ntA) *100./$lt)] \
[expr round(($ntT) *100./$lt)] \
[expr round(($ntG) *100./$lt)] \
[expr round(($ntC) *100./$lt)]"]
set FichierCompo "$RepertoireDuGenome/fiches/compositionenatgc"
return [SauveLesLignes $Liste dans "$FichierCompo"]
}
proc AfficheLeSpectreGC {K MinSpectreY MaxSpectreY } {
global RepertoireDuGenome
set FichierSpectre "$RepertoireDuGenome/fiches/spectregcxy"
if { ! [file exists $FichierSpectre]} { return }
set HauteurDuSpectreY [expr $MaxSpectreY-$MinSpectreY]
set LesCoordonnees ""
set n 0
set PremiereLigne 1
foreach Ligne [LesLignesDuFichier $FichierSpectre] {
if {$PremiereLigne} {
scan $Ligne "%d %d" xMin yMin
set PremiereLigne 0
set DeuxiemeLigne 1
continue
}
if {$DeuxiemeLigne} {
scan $Ligne "%d %d" xMax yMax
set DeuxiemeLigne 0
set TroisiemeLigne 1
continue
}
if {$TroisiemeLigne} {
scan $Ligne "%d %d" x yMoyen
set TroisiemeLigne 0
$K create line \
$xMin [expr $MaxSpectreY-($yMin-$yMin)*($HauteurDuSpectreY)/($yMax-$yMin)] \
$xMax [expr $MaxSpectreY-($yMin-$yMin)*($HauteurDuSpectreY)/($yMax-$yMin)]
$K create line \
$xMin [expr $MaxSpectreY-($yMoyen-$yMin)*($HauteurDuSpectreY)/($yMax-$yMin)] \
$xMax [expr $MaxSpectreY-($yMoyen-$yMin)*($HauteurDuSpectreY)/($yMax-$yMin)]
$K create line \
$xMin [expr $MaxSpectreY-($yMax-$yMin)*($HauteurDuSpectreY)/($yMax-$yMin)] \
$xMax [expr $MaxSpectreY-($yMax-$yMin)*($HauteurDuSpectreY)/($yMax-$yMin)]
continue
}
scan $Ligne "%d %d" x y
set XY " $x [expr $MaxSpectreY-($y-$yMin)*($HauteurDuSpectreY)/($yMax-$yMin)] "
append LesCoordonnees $XY
if {[incr n] > 100} {
eval $K create line $LesCoordonnees
set LesCoordonnees $XY
set n 1
}
}
if { $n > 1 } {
eval $K create line $LesCoordonnees
}
}
proc AfficheLeSpectreGCenCouleur {K PosLineY } {
global RepertoireDuGenome
foreach Ligne [LesLignesDuFichier "$RepertoireDuGenome/fiches/spectregc"] {
scan $Ligne "%d %d %s" d f Couleur
if {[regexp "green" $Couleur]} { continue }
$K create line $d $PosLineY $f $PosLineY -fill $Couleur -width 5
}
}
proc CreeLesFichiersSpectreDesGC {{SequenceADN ""} {Retour ""} {lWin 400}} {
global RepertoireDuGenome
if {$SequenceADN==""} {
global ADN TDN RAC
if { ! [info exists ADN]} { ChargeADNetTDNetRAC }
} else {
set ADN $SequenceADN
}
set l [string length $ADN]
set nGC 0
for {set i 0} {$i<$lWin} {incr i} {
set Win($i) "A"
set Win([incr i]) "C"
incr nGC
}
set pWin 0
set ntGC 0
set Mi 99
set Ma 0
set OldLimite 0
foreach Limite {25 35 50 100} Couleur {"red" "orange" "green" "blue"} {
for {set i $OldLimite} {$i < $Limite} {incr i} {
set CouleurDeLaBande($i) $Couleur
}
set OldLimite $Limite
}
set CouleurDeLaBande($Limite) $Couleur
set OldCouleur "cacadoie"
set Oldi 0
for {set i 1} {$i < $l} {incr i} {
set c [string index $ADN $i]
set w [set Win($pWin)]
if { $c == "G" || $c == "C" } { incr nGC 1 ; incr ntGC}
if { $w == "G" || $w == "C" } { incr nGC -1 }
set Win($pWin) $c
set pWin [expr ($pWin+1)%$lWin]
set NewpGC [expr ($nGC*100)/$lWin]
if {[expr $i>$lWin/2] && [expr $i%($lWin/4)] == 0} { lappend SpectreXY "[expr $i-$lWin/2] $NewpGC" }
set pGC $NewpGC
set Mi [Mini $Mi $NewpGC]
set Ma [Maxi $Ma $NewpGC]
set Couleur [set CouleurDeLaBande($pGC)]
if { $Couleur != $OldCouleur } {
lappend Spectre "[incr Oldi] $i $Couleur"
set Oldi $i
}
set OldCouleur $Couleur
}
set Moyen [expr ($ntGC*100)/[string length $ADN]]
set Entete [list "0 $Mi" "$Oldi $Ma" "0 $Moyen"]
set SpectreGCXY [concat $Entete $SpectreXY]
if {$Retour=="SpectreGCXY"} { return $SpectreGCXY }
set FichierSpectreXY "$RepertoireDuGenome/fiches/spectregcxy"
Espionne [SauveLesLignes $SpectreGCXY dans "$FichierSpectreXY"]
set FichierSpectre "$RepertoireDuGenome/fiches/spectregc"
Espionne [SauveLesLignes $Spectre dans "$FichierSpectre"]
}
proc RetexteUneBoite {Nom Texte K {Id ""}} {
global CouleurDuFond
if { $Id == "" } {
set Id [$K find withtag "Txt_$Nom"]
}
if { $Id == "" } { return "" }
set AvecOrganismesSimilaires 0
set TexteAvant ""
set TexteApres ""
if {$AvecOrganismesSimilaires} {
set OrganismesSimilaires [lrange [LesOrganismesTresProches] 0 1]
if { $OrganismesSimilaires == {}} { return [NomDeScene $Nom] }
if {[llength $OrganismesSimilaires] > 0} {
set OrgaAvant [lindex $OrganismesSimilaires 0]
if {[YaPABdans $Nom] && ! [ExisteOrthologueDans $OrgaAvant $Nom]} { set TexteAvant "+ " }
}
if {[llength $OrganismesSimilaires] > 1} {
set OrgaApres [lindex $OrganismesSimilaires 1]
if {[YaPABdans $Nom] && ! [ExisteOrthologueDans $OrgaApres $Nom]} { set TexteApres " +" }
}
}
set BonTexte "${TexteAvant}[NomDeScene $Nom]${TexteApres}"
$K itemconfigure $Id -text $BonTexte
return "$BonTexte"
}
proc ReColore {Marque Color} {
set tid [lindex [split $Marque :] 0]
set tc [lindex [split $Marque :] 1]
$tc itemconfigure $tid -fill $Color
}
proc ReTexte {Marque Texte} {
set tid [lindex [split $Marque :] 0]
set tc [lindex [split $Marque :] 1]
$tc itemconfigure [expr $tid +1] -text $Texte
}
proc ReelVersEcran {z zMin zMax ZMin ZMax} {
set zPlage [expr $zMax-$zMin]
if {[expr $zPlage == 0]} { set zPlage 1 }
set Z [expr $ZMin + (($z-$zMin)*($ZMax-$ZMin)) / $zPlage]
return $Z
}
proc CouleurAuNombreDeCopainsDansBlast {nCops {K ""}} {
global SeuilsNbCops
if { ! [info exists SeuilsNbCops]} {
if {[OnTraiteMS2PH]} {
set SeuilsNbCops(30) 300
set SeuilsNbCops(10) 100
set SeuilsNbCops(5) 50
set SeuilsNbCops(2) 2
set SeuilsNbCops(1) 1
set SeuilsNbCops(0) 0
set SeuilsNbCops(-1) -1
} elseif {[OnTraite "BaDe"]} {
set SeuilsNbCops(30) 300
set SeuilsNbCops(10) 100
set SeuilsNbCops(5) 50
set SeuilsNbCops(2) 10
set SeuilsNbCops(1) 1
set SeuilsNbCops(0) 0
set SeuilsNbCops(-1) -1
} elseif {[OnTraite "CilioCarta" "Like"]} {
set SeuilsNbCops(30) 5000
set SeuilsNbCops(10) 2500
set SeuilsNbCops(5) 500
set SeuilsNbCops(2) 100
set SeuilsNbCops(1) 3
set SeuilsNbCops(0) 0
set SeuilsNbCops(-1) -1
} elseif {[regexp "MsFinal" [RepertoireDuGenome]]} {
set SeuilsNbCops(30) 300
set SeuilsNbCops(10) 100
set SeuilsNbCops(5) 50
set SeuilsNbCops(2) 10
set SeuilsNbCops(1) 1
set SeuilsNbCops(0) 0
set SeuilsNbCops(-1) -1
} else {
#rR modifie 2014/03/28 car on en a beaucoup de nos jours !!!
set SeuilsNbCops(30) 200
set SeuilsNbCops(10) 100
set SeuilsNbCops(5) 10
set SeuilsNbCops(2) 5
set SeuilsNbCops(1) 1
set SeuilsNbCops(0) 0
set SeuilsNbCops(-1) -1
}
}
if {$nCops=="SetAllSignification"} {
SetSignification $K red "Blast hits : $SeuilsNbCops(30) <= n"
SetSignification $K orange "Blast hits : $SeuilsNbCops(10) <= n < $SeuilsNbCops(30)"
SetSignification $K yellow "Blast hits : $SeuilsNbCops(5) <= n < $SeuilsNbCops(10)"
SetSignification $K green "Blast hits : $SeuilsNbCops(2) <= n < $SeuilsNbCops(5)"
SetSignification $K blue "Blast hits : $SeuilsNbCops(1) < n < $SeuilsNbCops(2)"
SetSignification $K cyan "Blast hits : $SeuilsNbCops(1) = n "
SetSignification $K white "Blast hits : $SeuilsNbCops(0) = n "
SetSignification $K grey "Blast hits : no value available"
return
}
if {[expr $SeuilsNbCops(30) <= $nCops]} { return "red"}
if {[expr $SeuilsNbCops(10) <= $nCops]} { return "orange"}
if {[expr $SeuilsNbCops(5) <= $nCops]} { return "yellow"}
if {[expr $SeuilsNbCops(2) <= $nCops]} { return "green"}
if {[expr $SeuilsNbCops(1) < $nCops]} { return "cyan"}
if {[expr $SeuilsNbCops(1) == $nCops]} { return "blue"}
if {[expr $SeuilsNbCops(0) == $nCops]} { return "white"}
if {[expr $SeuilsNbCops(-1) == $nCops]} { return "grey"}
return "black"
}
proc HIDDEN_MiseAJourHtml {{W ""} {Action "Append"}} {
#rR ne sert certainement a rien ..... a supprimer
global MiseAJourHtml
if {$W==""} {
if {[info exists MiseAJourHtml]} {
return $MiseAJourHtml
} else {
return {}
}
}
if {$Action=="Append"} { return [lappend MiseAJourHtml $W] }
if {$Action=="Reset"} {
set Old [MiseAJourHtml]
set MiseAJourHtml {}
return $Old
}
}
proc RecoloreUneBoite {Nom TypeDeCouleur K {Id ""}} {
global CouleurDuFond
if {[regexp "GLIMMER" $Nom]} { return }
if { $Id == "" } {
set Id [$K find withtag $Nom]
}
if {[Fantome $Nom]} {
set Couleur $CouleurDuFond
set CouleurOutline "black"
} else {
set Couleur [CouleurParTypeEtNom $TypeDeCouleur $Nom $K]
set CouleurOutline $Couleur
}
if {[Enterre $Nom]} { set CouleurOutline "white" }
if {[regexp "rond" $K]} {
$K itemconfigure $Id -fill $Couleur
} else {
$K itemconfigure $Id -fill $Couleur -outline $CouleurOutline
}
}
proc RecoloreUnLinge {Nom TypeDeCouleur K {Id ""}} {
global CouleurDuFond
global ColorierLesBox ColorierLesLinges
if { $Id == "" } {
set Id [$K find withtag "Linge$Nom"]
}
if {0 && [Fantome $Nom]} {
set Couleur $CouleurDuFond
set CouleurOutline "black"
} else {
set Couleur [CouleurParTypeEtNom $TypeDeCouleur $Nom $K]
set CouleurOutline $Couleur
}
if {[Enterre $Nom]} { set CouleurOutline "white" }
$K itemconfigure $Id -fill $Couleur -outline $Couleur
}
proc RecoloreLesBoites {TypeDeCouleur K} {
global ListeDeBoites
OnColorieLesFrames 1
SetSignification $K "AnnulerToutesSignifications" ""
foreach Boite $ListeDeBoites {
if {[regexp "GLIMMER" $Boite]} { continue }
set Nom [Box $Boite nom]
set Id [$K find withtag "$Nom"]
RecoloreUneBoite $Nom $TypeDeCouleur $K $Id
}
OnColorieLesFrames 0
#?? MiseAJourHtml $K
return $K
}
proc RecoloreLesLinges {TypeDeCouleur K} {
global ListeDeBoites
SetSignification $K "AnnulerToutesSignifications" ""
foreach Boite $ListeDeBoites {
if {[regexp "GLIMMER" $Boite]} { continue }
set Nom [Box $Boite nom]
set Id [$K find withtag "Linge$Nom"]
RecoloreUnLinge $Nom $TypeDeCouleur $K $Id
}
#?? MiseAJourHtml $K
return $K
}
proc RedefinirLaCouleur {K {NouveauTypeCouleur ""} {Ou ""}} {
global TypeCouleur
global TypeCouleurDuLinge
global TypeFard
if {$Ou==""} { set Ou "Boite" }
Gs "UpdateK"
if {$NouveauTypeCouleur == ""} {
set NouveauTypeCouleur [ChoixColoration]
}
if { $NouveauTypeCouleur != "" } {
if {$K!="OrdrePourGif" && [regexp "PresenceAndAbsence" $NouveauTypeCouleur]} { ChoixDesGenomesCompletsPresentsAbsents Ask }
if {$NouveauTypeCouleur=="NombreDeCopainsDansBlast"} { NombreDeCopainsDansBlast "Reload" }
if {$NouveauTypeCouleur=="HomologDetectionAgreement"} { HomologDetectionAgreement "Reset" }
if {$NouveauTypeCouleur=="SameClusterXHda"} { ColorationDesClustersXHdaDesNomsPiques "Reset" }
if {$NouveauTypeCouleur=="FromTamis"} { CreeLeTasTamis }
if {$Ou=="Boite"} {
set TypeCouleur($K) $NouveauTypeCouleur
RecoloreLesBoites $NouveauTypeCouleur $K
}
if {$Ou=="Linge"} {
set TypeCouleurDuLinge($K) $NouveauTypeCouleur
RecoloreLesLinges $NouveauTypeCouleur $K
}
if {$Ou=="Fard"} {
set TypeFard($K) $NouveauTypeCouleur
}
}
return $K
}
proc RedefinirLaCouleurDuLinge {K {NouveauTypeCouleur ""}} {
return [RedefinirLaCouleur $K $NouveauTypeCouleur "Linge"]
}
proc RedefinirLeFard {K {NouveauTypeCouleur ""}} {
return [RedefinirLaCouleur $K $NouveauTypeCouleur "Fard"]
}
proc SetSignification {K Couleur {Signe ""}} {
global SignificationEnStock
if { ! [OnColorieLesFrames] } {
append K "_Linge"
}
if {$Couleur == "AnnulerToutesSignifications"} {
if {[info exists SignificationEnStock($K)]} {
foreach C [set SignificationEnStock($K)] {
catch {unset SignificationEnStock($C,$K)}
}
catch {unset SignificationEnStock($K)}
}
} else {
if { ! [info exists SignificationEnStock($Couleur,$K)]} {
lappend SignificationEnStock($K) $Couleur
set SignificationEnStock($Couleur,$K) $Signe
}
}
}
proc GetSignification {Couleur K} {
global SignificationEnStock
if {$Couleur == "ToutesLesCouleursPossibles"} {
if {[info exists SignificationEnStock($K)]} {
return [set SignificationEnStock($K)]
} else {
return ""
}
}
if {[info exists SignificationEnStock($Couleur,$K)]} {
return [set SignificationEnStock($Couleur,$K)]
} else {
return ""
}
}
proc ChoixDesGenomesCompletsPresentsAbsents {{Ask ""} {LesGenomesAChoisir ""}} {
global ChoixDesGenomesCompletsPresentsAbsents
global NotreOrga NotreOS
if {$LesGenomesAChoisir=={}} { set LesGenomesAChoisir [LesOrganismesImportantsPourDBClustal] }
if { ! [info exists ChoixDesGenomesCompletsPresentsAbsents] || $Ask!=""} {
set ChoixDesGenomesCompletsPresentsAbsents {}
foreach G $LesGenomesAChoisir {
set P [PhylumDuOrganisme $G]
lappend LesPGs "$P $G"
}
set LesPGs [lsort $LesPGs]
foreach PG $LesPGs {
scan $PG "%s" P
regsub "$P " $PG "" G
lappend LesGs $G
}
set PAI [LesPresentsAbsentsIndifferents $LesGs $LesPGs]
set LesPresents [lindex $PAI 0]
set LesAbsents [lindex $PAI 1]
foreach Organisme $LesPresents {
lappend ChoixDesGenomesCompletsPresentsAbsents [string toupper [Glossaire $Organisme Court]]
}
foreach Organisme $LesAbsents {
lappend ChoixDesGenomesCompletsPresentsAbsents [string tolower [Glossaire $Organisme Court]]
}
}
return $ChoixDesGenomesCompletsPresentsAbsents
}
proc SetListeDesPresentsAbsents Liste {
global ChoixDesGenomesCompletsPresentsAbsents
set ChoixDesGenomesCompletsPresentsAbsents $Liste
}
proc PresenceEtAbsenceDesGenomesComplets {Nom {Source ""}} {
if {$Source==""} { set Source "MSF" }
set TexteOo " [ORGAorgaDes${Source}s $Nom] "
foreach Oo [ChoixDesGenomesCompletsPresentsAbsents] {
if { ! [regexp -nocase $Oo $TexteOo]} { continue }
if { ! [regexp " $Oo " $TexteOo]} { return 0 }
}
return 1
}
proc TesteSavantEnBatch {} {
set Question "batch set x 3\nbatch set y \$x"
puts [QuestionDeScience Paby $Question]
exit
}
proc MiniDeLaListe LesX {
set MinX [lindex $LesX 0]
foreach X $LesX {
set MinX [Mini $X $MinX]
}
return $MinX
}
proc MaxiDeLaListe LesX {
set MaxX [lindex $LesX 0]
foreach X $LesX {
set MaxX [Maxi $X $MaxX]
}
return $MaxX
}
proc GrapheDuFichier {{Fichier ""} {Format}} {
if {$Format==""} { set Format "%f %f" }
if {$Format=="dpvd"} { set Format "%d;%d" }
if {$Fichier!=""} {
foreach Ligne [LesLignesDuFichier $Fichier] {
scan $Ligne $Format X Y
lappend LesX $X
lappend LesY $Y
}
return [Graphe $LesX $LesY "" "blue" 800 600]
}
}
proc TestGraphe {{Fichier ""}} {
set LaListeDesTags [list [list a] [list b] [list c] [list d] [list e] [list f] [list g] [list h]]
set K [Graphe {1 3 4 5 6 3 4 2} {3 4 2 1 3 4 4 5} "" "blue" 800 600 {} "" "Beau titre" $LaListeDesTags]
set G {1 3 2 5 2 3 2 2}
# Graphe $G "Regulier" $K "red" "" "" {400 400 500 550}
# Graphe [list 0 [llength $G]] [list [MiniDeLaListe $G] [MiniDeLaListe $G]] $K "red" "" "" {400 400 500 550}
$K create text 400 400 -text Coucou
MainLeveeSurUnCanva $K
set K2 [Graphe {1 3 4 5 6 3 4 2} {3 4 2 1 3 4 4 5} "" "blue" 800 600 {} "" "K2" $LaListeDesTags]
Espionne [GraphesEnStock]
}
proc GraphesEnStock {{Quoi ""} {K ""} {R ""}} {
global GraphesEnStock
global GraphesEnStockInfo
if {$Quoi==""} { set Quoi "GetList" }
if { ! [info exists GraphesEnStock]} { set GraphesEnStock {} }
if {[string equal -nocase "GetList" $Quoi]} { return $GraphesEnStock }
if {[string equal -nocase "Reset" $Quoi]} {
set Old $GraphesEnStock
set GraphesEnStock {}
return $Old
}
if {[string equal -nocase "HighlightId" $Quoi]} {
if {$R==""} {
if {[info exists GraphesEnStockInfo($K,HighlightId)]} {
return $GraphesEnStockInfo($K,HighlightId)
} else {
return ""
}
}
set GraphesEnStockInfo($K,HighlightId) $R
return $GraphesEnStockInfo($K,HighlightId)
}
if {[string equal -nocase "Remove" $Quoi]} {
set I [lsearch $GraphesEnStock $K]
set GraphesEnStock [lreplace $GraphesEnStock $I $I]
return $GraphesEnStock
}
if {[regexp "^\." $Quoi]} {
set K $Quoi
if { ! [regexp {(.*).canvas} $K Match w]} { return $GraphesEnStock}
set D "$w.buttons.dismiss"
$D configure -command "GraphesEnStock Remove $K; destroy $w"
lappend GraphesEnStock $Quoi
return $GraphesEnStock
}
return $GraphesEnStock
}
proc GrapheExpressedTissuesOLD {} {
set LesSi [string trim [string repeat "100 400 800 400 000 400 400 800 400 000 " 7]]
set K [Graphe $LesSi "EnBatons" "" "" 1000 500 "" "" "ExpressTiss" $LesSi]
$K create text 300 10 -text "Signal Intensities" -font {Arial 14}
}
proc Graphe {LesX {LesY {}} {K ""} {Couleur ""} {Largeur ""} {Hauteur ""} {CigCsd {}} {AvecAxes ""} {Titre ""} {LaListeDesTags ""} {DotOnly ""} {BindOnly ""} {LargeurMax ""} {HauteurMax ""}} {
global BornesDuGraphe
if {$BindOnly!=""} {
set LesBind [split $BindOnly "_"]
set BindOnly 1
} else {
set BindOnly 0
}
set DotOnly [string equal -nocase "DotOnly" $DotOnly]
set EnBatons 0
if {$LesY=="EnBatons"} { set LesY {} ; set EnBatons 1 }
if {$LesY=="Regulier"} { set LesY {}}
if {$Couleur==""} { set Couleur "black" }
if {$Largeur==""} {
if {$K==""} {
set Largeur 512
} else {
set Largeur [lindex [$K configure -width] 4]
}
}
if {$Hauteur==""} {
if {$K==""} {
set Hauteur 512
} else {
set Hauteur [lindex [$K configure -height] 4]
}
}
if {$CigCsd=={}} {
set CigCsd [list \
[expr $Largeur*0.05] [expr $Hauteur*0.05] \
[expr $Largeur*0.95] [expr $Hauteur*0.95]]
}
ScanLaListe $CigCsd GaucheX BasY DroiteX HautY
if {$LargeurMax==""} { set LargeurMax $Hauteur }
if {$HauteurMax==""} { set HauteurMax $Hauteur }
set LongX [llength $LesX]
if {$LongX==0} { return "" }
if {$LesY=={}} {
set LesY $LesX
if {$EnBatons} { set LesY [lreplace $LesY -1 -1 0] }
set LongY [llength $LesY]
set LesX [NombresEntre 0 [expr $LongY-1]]
}
if {[info exists BornesDuGraphe($K)]} {
ScanLaListe [set BornesDuGraphe($K)] MinX MinY MaxX MaxY
} else {
set MinX [MiniDeLaListe $LesX]
set MaxX [MaxiDeLaListe $LesX]
set MinY [MiniDeLaListe $LesY]
set MaxY [MaxiDeLaListe $LesY]
set NoDistorsion 0
if {$NoDistorsion} {
set MinX [Mini $MinX $MinY]
set MinY $MinX
set MaxX [Maxi $MaxX $MaxY]
set MaxY $MaxX
}
set BornesDuGrapheCourant [list $MinX $MinY $MaxX $MaxY]
}
if {$MinX==$MaxX} {
set PlageX 1
} else {
set PlageX [expr $MaxX - $MinX]
}
if {$MinY==$MaxY} {
set PlageY 1
} else {
set PlageY [expr $MaxY - $MinY]
}
set AX [expr 1.0*($DroiteX-$GaucheX)/$PlageX]
set AY [expr 1.0*($HautY -$BasY )/$PlageY]
set BX [expr $GaucheX-$AX*$MinX]
set BY [expr $BasY -$AY*$MinY]
if {$K==""} {
if {$EnBatons} {
set K [UnCanva $LargeurMax $HauteurMax $Hauteur $Largeur "" $Titre]
} else {
set K [UnCanva $LargeurMax $HauteurMax $Largeur $Hauteur "" $Titre]
}
set BornesDuGraphe($K) $BornesDuGrapheCourant
GraphesEnStock $K
}
foreach X $LesX Y $LesY {
lappend Lesx [expr $AX*$X + $BX]
lappend Lesy [expr $AY*$Y + $BY]
}
set Zerox [expr $AX*0 + $BX]
set Zeroy [expr $AY*0 + $BY]
set Oldx [lindex $Lesx 0]
set OldyM [expr $HauteurMax-[lindex $Lesy 0]]
set Prems 1
set MargeX 0
set MargeY 0
set BatonColors [list LightGreen LightBlue]
set iBC 0
set nBC [llength $BatonColors]
set os 4
Espionne $HauteurMax
foreach x $Lesx y $Lesy X $LesX Y $LesY LesTags $LaListeDesTags {
set yM [expr $HauteurMax-($y)]
lappend LesTags "|" $X $Y $x $yM
if {$EnBatons} {
set Color [lindex $BatonColors [expr [incr iBC]%$nBC]]
$K create rectangle [expr $Zeroy + $MargeY] [expr $Oldx + $MargeX] [expr $y + $MargeY] [expr $x + $MargeX] \
-fill $Color
if {[lindex $LesTags 0]!="|"} {
$K create text [expr $Zeroy + $MargeY +10] [expr $x + $MargeX -2] -text [lindex $LesTags 0] -anchor nw -tag "tissue"
}
} else {
$K create oval [expr $x-$os] [expr $yM-$os] [expr $x+$os] [expr $yM+$os] \
-fill $Couleur -outline $Couleur \
-tag [linsert $LesTags 1 oval]
if { ! $DotOnly} {
$K create line $Oldx [expr $OldyM] $x [expr $yM] \
-fill $Couleur \
-tag [linsert $LesTags 1 line]
}
}
set Oldx $x
set OldyM $yM
}
if {$BindOnly} {
foreach B $LesBind {
$K bind $B <Enter> "EntreDansCoeur $K %x %y"
$K bind $B <Leave> "SortDeCoeur $K %x %y"
}
} else {
$K bind "all" <Enter> "EntreDansCoeur $K %x %y"
$K bind "all" <Leave> "SortDeCoeur $K %x %y"
}
$K raise "tissue"
return $K
}
proc EntreDansCoeur {K X Y {Propagate ""}} {
if {$Propagate==""} { set Propagate "Propagate" }
if {[regexp {ShowAlso_(.+)} $Propagate Match IdTag]} {
set Id [$K find withtag $IdTag]
set SmallBox 1
} else {
set Id [$K find withtag current]
set SmallBox 0
}
set Moi [lindex [$K gettags $Id] 0]
set Toi [lindex [$K gettags $Id] 1]
#rR set Texte "$Moi $Toi"
set LesTags [$K gettags $Id]
set C [lindex $LesTags end]
if {$C=="current"} {
set X [lindex $LesTags end-2]
set Y [lindex $LesTags end-1]
} else {
set X [lindex $LesTags end-1]
set Y [lindex $LesTags end]
}
if { ! [regexp {[0-9.]+} "$X$Y"] } { return "" }
set Texte [join $LesTags " "]
if {$SmallBox} {
set R [$K create oval [expr $X-10] [expr $Y-10] [expr $X+10] [expr $Y+10] -outline "black"]
GraphesEnStock "HighlightId" $K $R
# append Texte " _$R"
}
regsub ".canvas" $K ".message" M
catch {destroy $M}
message $M -borderwidth 3 -font {Courier 12} -relief raise -width 300 -text $Texte -background "lightyellow" -foreground "black"
set AncreH ""
set AncreV "s"
if {$Y<500} { set AncreV "n" }
if {$X<128} { set AncreH "e" }
if {$X>384} { set AncreH "w" }
set Ancre "${AncreV}${AncreH}"
set XT [expr $X+30]
set YT [Maxi 100 [expr $Y-30]]
place $M -x [expr $X+10] -y [Maxi 100 [expr $Y-10]] -anchor $Ancre
$K create text $XT $YT -text $Texte -fill red -tags "MessageAffiche"
if {[string equal -nocase $Propagate "Propagate"]} {
foreach KK [GraphesEnStock] {
if {$KK==$K} { continue }
EntreDansCoeur $KK "" "" "ShowAlso_$Moi"
}
}
return $M
}
proc SortDeCoeur {K X Y {Propagate ""}} {
if {$Propagate==""} { set Propagate "Propagate" }
if {[set R [GraphesEnStock "HighlightId" $K]]!=""} { $K delete $R }
regsub ".canvas" $K ".message" M
catch {destroy $M}
if {[string equal -nocase $Propagate "Propagate"]} {
foreach KK [GraphesEnStock] {
if {$KK==$K} { continue }
SortDeCoeur $KK "" "" "DontPropagate"
}
}
$K delete "MessageAffiche"
}
proc Milieu Nom {
return [expr ([Box $Nom debut]+[Box $Nom fin])/2]
}
proc TGO {} {
Espionne [LesGenomesDansLeBonOrdre]
Espionne [LesGenomesDansLeBonOrdre]
}
proc ReOrdonneOoMSF {} {
global RepertoireDuGenome
set Fichier "$RepertoireDuGenome/fiches/oomsf"
set LesG [LesGenomesComplets]
set LesT [LesGenomesDansLeBonOrdre]
Espionne $LesG
Espionne $LesT
foreach Ligne [LesLignesDuFichier $Fichier] {
scan $Ligne "%s" Nom
foreach Oo [lrange [split $Ligne " "] 1 end] G $LesG {
set OoDuGenome($G) $Oo
}
set Liste [list $Nom]
foreach T $LesT {
lappend Liste [set OoDuGenome($T)]
}
Espionne [join $Liste " "]
lappend LaSortie [join $Liste " "]
}
Espionne [SauveLesLignes $LaSortie dans $Fichier.arenommer]
}
proc HistogrammeDesGC {} {
set Cumul 0
foreach Nom [ListeDesPABs] {
set GC [CompositionEn GC $Nom]
set Cumul [expr $Cumul + $GC]
lappend Liste $GC
}
scan [MoyenneEcartMinMaxCumulLong $Liste] "%f %f %d %d" Mo Ec Mi Ma
Espionne "$Mo $Ec [expr $Mo-2*$Ec] [expr $Mo+2*$Ec]"
Histogramme $Liste
exit
}
proc ToBeOrthologue {Nom {PlusMinusOrgas ""}} {
global ToBeOrthologue
if {[info exists ToBeOrthologue($PlusMinusOrgas)]} {
if {[info exists ToBeOrthologue($Nom)] } {
return [set ToBeOrthologue($Nom)]
} else {
return 0
}
}
if {[info exists ToBeOrthologue]} { unset ToBeOrthologue }
LaListeToBeOrthologue $PlusMinusOrgas
if {[info exists ToBeOrthologue($Nom)] } {
return [set ToBeOrthologue($Nom)]
} else {
return 0
}
}
proc LaListeToBeOrthologue {{PlusMinusOrgas ""}} {
global ToBeOrthologue
if {$PlusMinusOrgas==""} {
FaireLire "Please give a list of organisms with + and - (ie. +paby -mjan -phor +hsp)"
set PlusMinusOrgas [Entre]
if {$PlusMinusOrgas==""} { return {} }
}
set Texte $PlusMinusOrgas
regsub -all " " $Texte "" Texte
if { ! [regexp {^(\+|\-)} $Texte]} { set Texte "+$Texte" }
regsub -all {\+|\-} $Texte " &" Texte
regsub "^ " $Texte "" Texte
set LesVoulus {}
set LesExclus {}
foreach PMOrga [split $Texte " "] {
regsub {^(\+|\-)} $PMOrga "" Orga
if {[regexp {\+} $PMOrga]} { lappend LesVoulus $Orga }
if {[regexp {\-} $PMOrga]} { lappend LesExclus $Orga }
}
set LesCommeIlFaut {}
foreach Nom [ListeDesPABs] {
set ToBeOrthologue($Nom) 0
set Presents [ORGAorgaDesMSFs $Nom "Presents"]
set IlEnManqueUn 0
foreach Orga $LesVoulus {
if { ! [regexp -nocase $Orga $Presents]} { set IlEnManqueUn 1 ; break }
}
if {$IlEnManqueUn} { continue }
set YAUnExclu 0
foreach Orga $LesExclus {
if {[regexp -nocase $Orga $Presents]} { set YAUnExclu 1 ; break }
}
if {$YAUnExclu} { continue }
set ToBeOrthologue($Nom) 1
lappend LesCommeIlFaut $Nom
}
set ToBeOrthologue($PlusMinusOrgas) 1
return $LesCommeIlFaut
}
proc RecapitulatifDesOrthologues {Nom {TPA "OTPMA"}} {
global RecapitulatifDesOrthologues
global SeparationShowBox
if { ! [info exists SeparationShowBox]} {
set SeparationShowBox [string repeat "-" [string length [ORGAorgaDesMSFs $Nom]]]
}
set LesLignes "\n"
set Operons ""
set Names ""
if {[regexp "O" $TPA] && [ORGAorgaDesOperons]!="ORGAorgaNonValide"} {
set Names [ORGAorgaDesOperons $Nom "Names"]
set Operons [ORGAorgaDesOperons $Nom "Stars"]
lappend LesLignes " Operons: $Operons"
}
set TBlastNs ""
if {[regexp "T" $TPA] && [ORGAorgaDesTBlastNs]!="ORGAorgaNonValide"} {
set Names [ORGAorgaDesTBlastNs $Nom "Names"]
set TBlastNs [ORGAorgaDesTBlastNs $Nom "Stars"]
lappend LesLignes " TBlastN: $TBlastNs"
}
if {[regexp "P" $TPA] && [ORGAorgaDesBlastPs]!="ORGAorgaNonValide"} {
set Names [ORGAorgaDesBlastPs $Nom "Names"]
set BlastPs [ORGAorgaDesBlastPs $Nom "Stars"]
lappend LesLignes " BlastP: $BlastPs"
}
if {[ORGAorgaDesMSFs]!="ORGAorgaNonValide"} {
set Names [ORGAorgaDesMSFs $Nom "Names"]
if {[regexp "M" $TPA]} {
set Missed [ORGAorgaDesMSFs $Nom "StarsP"]
lappend LesLignes " InAlign: $Missed"
}
if {[regexp "A" $TPA]} {
set DbClustal [ORGAorgaDesMSFs $Nom "Stars"]
lappend LesLignes " WellAlign: $DbClustal"
}
}
lappend LesLignes $Names
return [join $LesLignes "\n"]
}
proc OrgasPresentsDesGenomesComplets Nom {
return [ORGAorgaDesMSFs $Nom "Presents"]
}
proc OrgasHesitantsDesGenomesComplets Nom {
return [ORGAorgaDesMSFs $Nom "Hesitants"]
}
proc OrgasAbsentsDesGenomesComplets Nom {
return [ORGAorgaDesMSFs $Nom "Absents"]
}
proc AfficheORGAorgaDesMSFs {{Etat ""}} {
foreach Nom [ListeDesPABs] {
lappend LesORGAorga "$Nom [ORGAorgaDesMSFs $Nom $Etat]"
}
AfficheVariable [join $LesORGAorga "\n"] "AvecRien" "OrthologuesInCompleteGenomes"
}
proc PhylumDuOrganisme {Organisme {Espece ""}} {
if {$Espece!=""} { set Organisme "$Organisme $Espece" }
set OS [Glossaire $Organisme Complet]
if {$OS!=""} {
# set OC [QuestionDeScience QuidSeq "QuidOCOfOS $OS"]
set OC [OCduOS $OS]
} else {
set OS "Inconnu inconnu"
set OC "Class unknown"
}
return [PhylumDuOC $OC]
}
proc PhylumDuOC OC {
if {[regexp -nocase "^Bacteria" $OC]} { return "B" }
if {[regexp -nocase "^Archaea" $OC]} { return "A" }
if {[regexp -nocase "^Eukaryota" $OC]} { return "E" }
if {[regexp -nocase "^Virus" $OC]} { return "V" }
return "X"
}
proc PhylumDuGenome {Genome {Quoi "Phylum"}} {
global PhylumDuGenome
global RepertoireDuGenome
set FichierPhylumDuGenome "$RepertoireDuGenome/fiches/phylumdugenome"
Wup "returns B A E V X or the whole class if Quoi is OC"
if {[info exists PhylumDuGenome($Genome,$Quoi)]} { return [set PhylumDuGenome($Genome,$Quoi)] }
if {[file exists $FichierPhylumDuGenome]} {
array set PhylumDuGenome [LesLignesDuFichier $FichierPhylumDuGenome]
} else {
foreach G [LesGenomesComplets] {
set OS [Glossaire $G Complet]
regsub " " $OS "_" Genre_espece
lappend LesGenre_espece $Genre_espece
}
set Genres_especes [join $LesGenre_espece "|"]
set Retour [QuestionDeScience QuidSeq "QuidOCsOfOSs $Genres_especes"]
foreach Ligne [split $Retour "\n"] {
set OC "Class unknown"
ScanLaListe [split $Ligne ":"] OS OC
set PhylumDuGenome($OS,OC) $OC
set BAEV [PhylumDuOC $OC]
set PhylumDuGenome($OS,Phylum) $BAEV
}
if {[OuiOuNon "Do I save PhylumDuGenome in $FichierPhylumDuGenome ?"]} {
SauveLesLignes [array get PhylumDuGenome] dans $FichierPhylumDuGenome
}
}
if {[info exists PhylumDuGenome($Genome,$Quoi)]} { return [set PhylumDuGenome($Genome,$Quoi)] }
if {[file exists $FichierPhylumDuGenome]} {
set OC "Inconnu inconnu"
} else {
Wup "Next lines is for an organism outsite LesGenomesComplets"
regsub " " $Genome "_" G_E
set OC [QuestionDeScience QuidSeq "QuidOCOfOS $G_E"]
}
if {$Quoi=="OC"} {
return $OC
} else {
return [PhylumDuOC $OC]
}
}
proc LesGenomesDansLeBonOrdre {{Ordre "BAE"} {QueVeutOn ""}} {
global LesGenomesDansLeBonOrdre
if {$Ordre=="OC"} { set QueVeutOn $Ordre ; set Ordre "BAE" }
Wup "If QueVeutOn is OC it returns the OCs list. (Works only for BAE, not for Original)"
if {$QueVeutOn=="" && [info exists LesGenomesDansLeBonOrdre($Ordre)]} {
return [set LesGenomesDansLeBonOrdre($Ordre)]
}
if { $QueVeutOn!=""} {
if { ! [info exists LesGenomesDansLeBonOrdre($Ordre,$QueVeutOn)]} {
LesGenomesDansLeBonOrdre $Ordre
}
return [set LesGenomesDansLeBonOrdre($Ordre,$QueVeutOn)]
}
set LesGenomes [LesGenomesComplets]
if {$Ordre=="Original"} {
set LesGenomesDansLeBonOrdre($Ordre) $LesGenomes
return $LesGenomes
}
if {$Ordre=="Alpha"} {
return [lsort $LesGenomes]
}
foreach Genome $LesGenomes {
set OS [Glossaire $Genome Complet]
if {[info exists DejaVu($OS)]} {
FaireLire "$OS\n is the organism of the genome $Genome\n \
but\n is also the organism of the genome [set GenomeDuOS($OS)] \
It can be a source of problems ..."
}
set DejaVu($OS) 1
set OC [PhylumDuGenome $OS OC]
set OSduGenome($Genome) $OS
set OCduGenome($Genome) $OC
set GenomeDuOS($OS) $Genome
set OCaTrier $OC
if {$Ordre=="BAE"} {
regsub -nocase "^Bacteria" $OCaTrier "2_Bacteria" OCaTrier
regsub -nocase "^Archaea" $OCaTrier "4_Archaea" OCaTrier
regsub -nocase "^Eukaryota" $OCaTrier "6_Eukaryota" OCaTrier
regsub -nocase "^Virus" $OCaTrier "9_Virus" OCaTrier
}
if {$Ordre=="FamiliarBAE"} {
regsub -nocase "^Bacteria" $OCaTrier "2_Bacteria" OCaTrier
regsub -nocase "^Archaea" $OCaTrier "4_Archaea" OCaTrier
regsub -nocase "^Eukaryota" $OCaTrier "6_Eukaryota" OCaTrier
regsub -nocase "^Virus" $OCaTrier "9_Virus" OCaTrier
if {[FamiliarOrganism $OS]} {
set OCaTrier "0_$OCaTrier"
}
}
if {$Ordre=="SampledBAE"} {
regsub -nocase "^Bacteria" $OCaTrier "2_Bacteria" OCaTrier
regsub -nocase "^Archaea" $OCaTrier "4_Archaea" OCaTrier
regsub -nocase "^Eukaryota" $OCaTrier "6_Eukaryota" OCaTrier
regsub -nocase "^Virus" $OCaTrier "9_Virus" OCaTrier
if {[SampledOrganism $OS]} {
set OCaTrier "0_$OCaTrier"
}
}
lappend LesOSOCs [list $OCaTrier $OS]
}
set LesOSOCsTries [lsort -index 0 $LesOSOCs]
foreach LeOCOS $LesOSOCsTries {
ScanLaListe $LeOCOS OCaTrier OS
set Genome [set GenomeDuOS($OS)]
lappend LesGenomesTries $Genome
lappend LesOCDesGenomesTries [set OCduGenome($Genome)]
}
set LesGenomesDansLeBonOrdre($Ordre) $LesGenomesTries
set LesGenomesDansLeBonOrdre($Ordre,OC) $LesOCDesGenomesTries
return $LesGenomesTries
}
proc CreeOrthoBlastP {{NomVoulu ""}} {
global RepertoireDuGenome
set FichierOBP "$RepertoireDuGenome/fiches/orthoblastp"
set ApnsOnly 0
set DaedalusOnly [OuiOuNon "Do I use only the organisms I'll find in the DaedalusHit files ?"]
if { ! $DaedalusOnly} {
set ApnsOnly [OuiOuNon "Do I use only the organisms I'll find in the ./apns files ?"]
}
while {[file exists $FichierOBP]} {
if {[OuiOuNon "$FichierOBP already exists\nDo I replace it ?"]} {
File delete -force $FichierOBP
continue
}
if {[OuiOuNon "$FichierOBP already exists\nDo I append to it (keeping existing lines) ?"]} {
foreach Ligne [LesLignesDuFichier $FichierOBP] {
scan $Ligne "%s" Nom
set DejaVu($Nom) 1
}
break
}
}
set SeuilExpect 0.001
scan [TailleSortiePourDBClustal] "%d %d" MinObliges MaxVoulus
set MaxListe [Maxi 250 [expr 3*$MaxVoulus]]
if {$NomVoulu==""} {
set Liste [ListeDesPABs]
} else {
set Liste [list $NomVoulu]
}
if {$DaedalusOnly} {
foreach Nom $Liste {
Espionne "Je repertorie les cops de $Nom"
if {[info exists DejaVu($Nom)]} { continue }
set FichierDaedalus "$RepertoireDuGenome/daedalushits/$Nom"
if { ! [file exists $FichierDaedalus]} { continue }
set nLu 0
set MesOrgas {}
foreach Ligne [LesLignesDuFichier $FichierDaedalus] {
set Valeurs [ValeurDeLaBalise BlastHit Ligne "" BH]
ValeurDeLaBalise AC Valeurs "NePasRogner" AC
# ValeurDeLaBalise ID Valeurs "NePasRogner" ID
ValeurDeLaBalise PN Valeurs "NePasRogner" PN
# ValeurDeLaBalise OX Valeurs "NePasRogner" OX
# ValeurDeLaBalise GN Valeurs "NePasRogner" GN
# ValeurDeLaBalise DE Valeurs "NePasRogner" DE
ValeurDeLaBalise OS Valeurs "NePasRogner" OS
if {[EstUnAccessPDB $AC]} { continue }
if {$PN > $SeuilExpect} { break }
if {[incr nLu] > $MaxListe} { break }
scan $OS "%s %s" Genre Espece
regsub -all {[\.\,\;]} $Espece "" Espece
set Orga "${Genre}_$Espece"
lappend MesOrgas $Orga
}
set MoiEtMesOrgas "$Nom [join $MesOrgas " "]"
Espionne $MoiEtMesOrgas
if {$MesOrgas!={}} { AppendAuFichier $FichierOBP $MoiEtMesOrgas }
}
} else {
foreach Nom $Liste {
Espionne "Je repertorie les cops de $Nom"
if {[info exists DejaVu($Nom)]} { continue }
set FichierAPNs "$RepertoireDuGenome/apns/$Nom"
if { ! [file exists $FichierAPNs]} { continue }
set nLu 0
set LesAccess {}
foreach Ligne [LesLignesDuFichier $FichierAPNs] {
scan $Ligne "%s %s %s" BanqueId Access Expect
if {[EstUnAccessPDB $BanqueId]} { continue }
incr nLu
if {$Expect > $SeuilExpect} { break }
if {$nLu > $MaxListe} { break }
lappend LesAccess $Access
set GEs ""
regsub " *$BanqueId +$Access +$Expect *" $Ligne "" GEs
if { ! [regexp -nocase {[a-z]} $GEs]} { continue }
set OrgaTrouve([string toupper $Access]) $GEs
}
if { ! $ApnsOnly} {
foreach AGEs [LesOrgasDesAccess $LesAccess] {
scan $AGEs "%s" A
regsub "$A " $AGEs "" GEs
regsub {(^|\:)Inconnu inconnu($|\:)} $GEs "" GEs
if {$GEs==""} { continue }
set OrgaTrouve([string toupper $A]) $GEs
}
}
set MesOrgas {}
set nLu 0
foreach Ligne [LesLignesDuFichier $FichierAPNs] {
scan $Ligne "%s %s %f" BanqueId Access Expect
if {[EstUnAccessPDB $BanqueId]} { continue }
incr nLu
if {$Expect > $SeuilExpect} { break }
if {$nLu > $MaxListe} { break }
set ACCESS [string toupper $Access]
set Orgas ""
if {[info exists OrgaTrouve($ACCESS)]} {
set Orgas [set OrgaTrouve($ACCESS)]
} else {
if { ! $ApnsOnly } {
set Orgas [OrgaDuAccess $Access Complet $BanqueId]
}
}
foreach Orga [split $Orgas ":"] {
if {$Orga=="" || $Orga=="Inconnu inconnu"} { continue }
regsub " " $Orga "_" Orga
lappend MesOrgas $Orga
}
}
if {$MesOrgas!={}} { AppendAuFichier $FichierOBP "$Nom [join $MesOrgas " "]" }
}
}
return $FichierOBP
}
proc OrthoBlastP {Nom {Orga ""} {OrgaOK ""}} {
global OrthoBlastP
global RepertoireDuGenome
Wup "returns its rank (starting 1) if Orga has an expect < 0.001 in BlastP, 0 if no absent"
Wup "returns OrthoBlastPNonValide if blastp not yet analyzed"
if {$OrgaOK=="OrgaOK"} { set OrgaOK 1 } else { set OrgaOK 0 }
if {$Orga !="" } {
if {$OrgaOK} {
set Organisme $Orga
} else {
set Organisme [Glossaire $Orga Complet]
}
regsub " " $Organisme "_" Organisme
if {$Organisme==""} { return 0 }
} else {
set Organisme "LaListeMerci"
}
set NO "$Nom,$Organisme"
if { [info exists OrthoBlastP($NO)]} {
return [set OrthoBlastP($NO)]
}
set FichierOBP "$RepertoireDuGenome/fiches/orthoblastp"
if { ! [info exists OrthoBlastP("EstCharge")]} {
set OrthoBlastP("EstCharge") "EstCharge"
if { ! [file exists $FichierOBP]} {
if { ! [info exists QuestionDejaPoseePourCreeOrthoBlastP]} {
set QuestionDejaPoseePourCreeOrthoBlastP 1
if {[OuiOuNon "Do I create \n$FichierOBP\n ?" 0]} {
CreeOrthoBlastP
} else {
return "OrthoBlastPNonValide"
}
} else {
return "OrthoBlastPNonValide"
}
}
Espionne "Je charge $FichierOBP"
set LesOrgasDeBlastP {}
foreach Ligne [LesLignesDuFichier $FichierOBP] {
set Liste [split $Ligne " "]
set NomLu [lindex $Liste 0]
set ieme 1
set OrthoBlastP($NomLu,LaListeMerci) {}
foreach OrgaLu [lrange $Liste 1 end] {
lappend OrthoBlastP($NomLu,LaListeMerci) $OrgaLu
if { ! [info exists DejaVu($OrgaLu)]} {
lappend LesOrgasDeBlastP $OrgaLu
set DejaVu($OrgaLu) 1
}
set NOlu "$NomLu,$OrgaLu"
set OrthoBlastP($NOlu) $ieme
}
}
set OrthoBlastP(LaListeMerci,LaListeMerci) $LesOrgasDeBlastP
}
if {[info exists OrthoBlastP($NO)]} {
return [set OrthoBlastP($NO)]
} else {
return 0
}
}
proc CreeOrthoTBlastN {} {
global RepertoireDuGenome
set FichierOrthoTBlastN "$RepertoireDuGenome/fiches/orthotblastn"
set FichierOuATapeTBN "$RepertoireDuGenome/fiches/ouatapetbn.genomes"
while { ! [file exists $FichierOuATapeTBN]} {
if { ! [OuiOuNon "$FichierOuATapeTBN\n doesn't exist \n\
Do You want to do it now ?" 0]} { return "" }
AnalyseLesTBlastN
return ""
}
set ToggleOrgaPositions 1
foreach Ligne [LesLignesDuFichier $FichierOuATapeTBN] {
if {$ToggleOrgaPositions} {
scan $Ligne "%s" Nom
set LesOrgas [lrange [split $Ligne " "] 1 end]
set ToggleOrgaPositions [expr ! $ToggleOrgaPositions]
continue
} else {
scan $Ligne "%s" NomLu
if {$NomLu!=$Nom} { FaireLire "Ca merde dans CreeOrthoTBlastN\n$Ligne" }
set LesPositions [lrange [split $Ligne " "] 1 end]
set ToggleOrgaPositions [expr ! $ToggleOrgaPositions]
}
catch {unset DejaVu}
set LesOrgasMaPosTaPos {}
foreach Orga $LesOrgas {MaPos TaPos} $LesPositions {
if {[info exists DejaVu($Orga)]} { continue }
lappend LesOrgasMaPosTaPos $Orga $MaPos $TaPos
}
Espionne $Nom
lappend Sortie "$Nom [join $LesOrgasMaPosTaPos " "]"
}
return [SauveLesLignes $Sortie dans $FichierOrthoTBlastN]
}
proc OrthoTBlastN {Nom Orga} {
global RepertoireDuGenome
global OrthoTBlastN
global LesOrgasDeTBlastN
global NotreOS
global QuestionDejaPoseePourCreeOrthoTBlastN
set NO "$Nom,$Orga"
if { [info exists OrthoTBlastN($NO)]} {
return [set OrthoTBlastN($NO)]
}
set FichierOTBN "$RepertoireDuGenome/fiches/orthotblastn"
if {$Nom == "LaListe"} { set RendreLaListe 1 } else { set RendreLaListe 0 }
if { ! [info exists OrthoTBlastN("EstCharge")]} {
set OrthoTBlastN("EstCharge") "EstCharge"
if { ! [file exists $FichierOTBN]} {
if { ! [info exists QuestionDejaPoseePourCreeOrthoTBlastN]} {
set QuestionDejaPoseePourCreeOrthoTBlastN 1
if {[OuiOuNon "Do I create \n$FichierOTBN\n ?"]} {
CreeOrthoTBlastN
} else {
return "OrthoTBlastNOrgaNonValide"
}
} else {
return "OrthoTBlastNOrgaNonValide"
}
}
Espionne "Je charge $FichierOTBN"
foreach Ligne [LesLignesDuFichier $FichierOTBN] {
set Liste [split $Ligne " "]
set NomLu [lindex $Liste 0]
set ListeOrgaMaPosTaPos [lrange $Liste 1 end]
foreach {OrgaLu MaPos TaPos} $ListeOrgaMaPosTaPos {
if {[info exists OrthoTBlastN($NomLu,$OrgaLu)]} { continue }
if { ! [info exists DejaVu($OrgaLu)]} {
lappend LesOrgasDeTBlastN $OrgaLu
set DejaVu($OrgaLu) 1
}
set NOlu "$NomLu,$OrgaLu"
set OrthoTBlastN($NOlu) "$MaPos:$TaPos"
}
}
}
if {$RendreLaListe} { return $LesOrgasDeTBlastN }
if {[info exists OrthoTBlastN($NO)]} {
return [set OrthoTBlastN($NO)]
} else {
return "-1:-1"
}
}
proc ORGAorgaDesTBlastNs {{Nom ""} {Etat ""}} {
global OosTBN Oos
global RepertoireDuGenome
Wup "Create fiches/ootblastn if necessary"
set CreerDeTouteFacon 0
if {$Nom=="CreateIt"} {
set CreerDeTouteFacon 1
if {[info exists OosTBN("EstCharge")]} { unset OosTBN }
}
if {[info exists OosTBN("EstCharge")] && $Nom=="" && [set OosTBN("EstCharge")]=="ORGAorgaNonValide"} {
return "ORGAorgaNonValide"
}
set FichierOosTBN "$RepertoireDuGenome/fiches/ootblastn"
if { ! [info exists OosTBN("EstCharge")]} {
if {[file exists $FichierOosTBN] && ! $CreerDeTouteFacon} {
foreach Ligne [LesLignesDuFichier $FichierOosTBN] {
scan $Ligne "%s" PAB
regsub "$PAB " $Ligne "" Reste
set OosTBN($PAB) $Reste
}
set OosTBN("EstCharge") 1
}
}
if { ! [info exists OosTBN("EstCharge")]} {
set LesNomOosTBN {}
if {[OrthoTBlastN "est-il" "valide"]!="OrthoTBlastNNonValide"} {
if { $CreerDeTouteFacon || [OuiOuNon " Do I create \n$FichierOosTBN\n ?" 0]} {
while {[file exists $FichierOosTBN]} {
if {[OuiOuNon "$FichierOosTBN\n already exists. Do I replace it ?" 0]} {
File delete $FichierOosTBN
break
}
if {[OuiOuNon "Do I append to it ? "]} {
foreach Ligne [LesLignesDuFichier $FichierOosTBN] {
scan $Ligne "%s" PAB
regsub "$PAB " $Ligne "" Reste
set OosTNB($PAB) $Reste
set DejaVu($PAB) 1
}
break
}
if {[OuiOuNon "Do I cancel ?"]} { return "" }
}
} else {
set OosTBN("EstCharge") "ORGAorgaNonValide"
return "ORGAorgaNonValide"
}
set LesOrgas {}
foreach Complet [LesGenomesDansLeBonOrdre] {
lappend LesOrgas [Glossaire $Complet Court]
}
foreach PAB [ListeDesPABs] {
if {[info exists DejaVu($PAB)]} { continue }
set LesOosTBN {}
foreach Orga $LesOrgas {
# set BelOrga [string range "$Orga..." 0 3]
set BelOrga $Orga
set PosTBN [OrthoTBlastN $PAB $Orga]
if {$PosTBN == "-1:-1"} {
set Oo [string tolower $BelOrga]
} else {
set Oo [string toupper $BelOrga]
}
lappend LesOosTBN $Oo
}
set OosTBN($PAB) [join $LesOosTBN " "]
AppendAuFichier $FichierOosTBN "$PAB [set OosTBN($PAB)]"
}
} else {
set OosTBN("EstCharge") "ORGAorgaNonValide"
return "ORGAorgaNonValide"
}
set OosTBN("EstCharge") 1
}
if {$Nom!=""} {
if {[info exists OosTBN($Nom)]} {
set Retour [set OosTBN($Nom)]
if {$Etat=="Names"} {
if {[info exists Oos("Names")]} { return [set Oos("Names")] }
set Oos("Names") [VerticalNames $Retour]
return [set Oos("Names")]
}
if {$Etat=="Stars"} {
regsub -all {\.} $Retour "" Retour
append Retour "/"
regsub -all { +} $Retour "/" Retour
regsub -all {[A-Z]+/} $Retour "*" Retour
regsub -all {[A-Za-z]+} $Retour " " Retour
regsub -all {/+} $Retour "" Retour
regsub -all {\*} $Retour "T" Retour
}
if {$Etat=="Presents"} { regsub -all {[A-Z][a-z][a-z\.]+|[a-z][a-z\.]+} $Retour " " Retour }
if {$Etat=="Absents"} { regsub -all {[A-Z][A-Za-z\.]+} $Retour " " Retour }
return $Retour
} else {
return ""
}
}
}
proc CorrigeOo {{Oo ""}} {
set LesOrgas {}
foreach Complet [LesGenomesDansLeBonOrdre] {
lappend LesOrganismes $Complet
lappend LesOrgas [Glossaire $Complet Court]
}
set FichierOo "[RepertoireDuGenome]/fiches/$Oo"
set Different 0
set Hit(Bidon) "coucou"
foreach Ligne [LesLignesDuFichier $FichierOo] {
set LesMots [LesMotsDeLaLigne $Ligne]
set Nom [lindex $LesMots 0]
unset Hit
foreach Mot [lrange $LesMots 1 end] {
set Orga [string tolower $Mot]
set Hit($Orga) $Mot
}
set LeNew [list $Nom]
foreach Orga $LesOrgas {
set o [string tolower $Orga]
if {[info exists Hit($Orga)]} { Espionne "$o $Orga $Hit($Orga)" ; set o $Hit($Orga) }
lappend LeNew $o
}
set New [join $LeNew " "]
if {$New!=$Ligne} { set Different 1 }
lappend LeBonOo $New
}
if { ! $Different} { return "" }
Garde $FichierOo
return [SauveLesLignes $LeBonOo dans $FichierOo]
}
proc ORGAorgaDesBlastPs {{Nom ""} {Etat ""}} {
global OosBP Oos
global RepertoireDuGenome
Wup "Create fiches/ooblastp if necessary"
set CreerDeTouteFacon 0
if {$Nom=="CreateIt"} {
set CreerDeTouteFacon 1
if {[info exists OosBP("EstCharge")]} { unset OosBP }
}
if {[info exists OosBP("EstCharge")] && $Nom=="" && [set OosBP("EstCharge")]=="ORGAorgaNonValide"} {
return "ORGAorgaNonValide"
}
set FichierOosBP "$RepertoireDuGenome/fiches/ooblastp"
if { ! [info exists OosBP("EstCharge")]} {
if {[file exists $FichierOosBP] && ! $CreerDeTouteFacon} {
foreach Ligne [LesLignesDuFichier $FichierOosBP] {
scan $Ligne "%s" PAB
regsub "$PAB " $Ligne "" Reste
set OosBP($PAB) $Reste
}
set OosBP("EstCharge") 1
}
}
if { ! [info exists OosBP("EstCharge")]} {
set LesNomOosBP {}
if {[OrthoBlastP "est-il" "valide"]!="OrthoBlastPNonValide"} {
if { $CreerDeTouteFacon || [OuiOuNon " Do I create \n$FichierOosBP\n ?" 0]} {
while {[file exists $FichierOosBP]} {
if {[OuiOuNon "$FichierOosBP\n already exists. Do I replace it ?" 0]} {
File delete $FichierOosBP
break
}
if {[OuiOuNon "Do I append to it ? "]} {
foreach Ligne [LesLignesDuFichier $FichierOosBP] {
scan $Ligne "%s" PAB
regsub "$PAB " $Ligne "" Reste
set OosBP($PAB) $Reste
set DejaVu($PAB) 1
}
break
}
if {[OuiOuNon "Do I cancel ?"]} { return "" }
}
} else {
set OosBP("EstCharge") "ORGAorgaNonValide"
return "ORGAorgaNonValide"
}
set LesOrgas {}
foreach Complet [LesGenomesDansLeBonOrdre] {
lappend LesOrganismes $Complet
lappend LesOrgas [Glossaire $Complet Court]
}
foreach PAB [ListeDesPABs] {
if {[info exists DejaVu($PAB)]} { continue }
set LesOosBP {}
foreach Orga $LesOrgas Organisme $LesOrganismes {
# set BelOrga [string range "$Orga..." 0 3]
set BelOrga $Orga
set YaBP [OrthoBlastP $PAB $Organisme "OrgaOK"]
if {$YaBP} {
set Oo [string toupper $BelOrga]
} else {
set Oo [string tolower $BelOrga]
}
lappend LesOosBP $Oo
}
set OosBP($PAB) [join $LesOosBP " "]
AppendAuFichier $FichierOosBP "$PAB [set OosBP($PAB)]"
}
} else {
set OosBP("EstCharge") "ORGAorgaNonValide"
return "ORGAorgaNonValide"
}
set OosBP("EstCharge") 1
}
if {$Nom!=""} {
if {[info exists OosBP($Nom)]} {
set Retour [set OosBP($Nom)]
if {$Etat=="Names"} {
if {[info exists Oos("Names")]} { return [set Oos("Names")] }
set Oos("Names") [VerticalNames $Retour]
return [set Oos("Names")]
}
if {$Etat=="Stars"} {
regsub -all {\.} $Retour "" Retour
append Retour "/"
regsub -all { +} $Retour "/" Retour
regsub -all {[A-Z]+/} $Retour "*" Retour
regsub -all {[A-Za-z]+} $Retour " " Retour
regsub -all {/+} $Retour "" Retour
regsub -all {\*} $Retour "P" Retour
}
if {$Etat=="Presents"} { regsub -all {[A-Z][a-z][a-z\.]+|[a-z][a-z\.]+} $Retour " " Retour }
if {$Etat=="Absents"} { regsub -all {[A-Z][A-Za-z\.]+} $Retour " " Retour }
return $Retour
} else {
return ""
}
}
}
proc ORGAorgaDesMSFs {{Nom ""} {Etat ""}} {
global Oos
global RepertoireDuGenome
global NotreOS
global NotreOrga
Wup "Create fiches/oomsf if necessary"
set CreerDeTouteFacon 0
if {$Nom=="CreateIt"} {
set CreerDeTouteFacon 1
if {[info exists Oos("EstCharge")]} { unset Oos }
}
if {[info exists Oos("EstCharge")] && $Nom=="" && [set Oos("EstCharge")]=="ORGAorgaNonValide"} {
return "ORGAorgaNonValide"
}
set FichierOos "$RepertoireDuGenome/fiches/oomsf"
if { ! [info exists Oos("EstCharge")]} {
if {[file exists $FichierOos] && ! $CreerDeTouteFacon} {
foreach Ligne [LesLignesDuFichier $FichierOos] {
scan $Ligne "%s" PAB
regsub "$PAB " $Ligne "" Reste
set Oos($PAB) $Reste
}
set Oos("EstCharge") 1
}
}
if { ! [info exists Oos("EstCharge")]} {
set LesNomOos {}
if {[PourcentageIdentiteOrga "est-il" "valide"]=="PourcentageIdentiteOrgaNonValide"} {
set Oos("EstCharge") "ORGAorgaNonValide"
return "ORGAorgaNonValide"
} else {
if { $CreerDeTouteFacon || \
[OuiOuNon " Do I create \n$FichierOos\n ... It would take a while ... ?" 0]} {
if {[file exists $FichierOos]} {
if {[OuiOuNon "$FichierOos\n already exists. Do I replace it ?" 0]} {
File delete $FichierOos
} else {
if {[OuiOuNon "Do I append to it ? "]} {
foreach Ligne [LesLignesDuFichier $FichierOos] {
scan $Ligne "%s" PAB
regsub "$PAB " $Ligne "" Reste
set Oos($PAB) $Reste
set DejaVu($PAB) 1
}
} else {
if {[OuiOuNon "Do I cancel ?"]} { return "" } else { }
}
}
}
} else {
set Oos("EstCharge") "ORGAorgaNonValide"
return "ORGAorgaNonValide"
}
set LesOrgas {}
foreach Complet [LesGenomesDansLeBonOrdre] {
lappend LesOrgas [Glossaire $Complet Court]
}
foreach PAB [ListeDesPABs] {
if {[info exists DejaVu($PAB)]} { continue }
set LesOos {}
foreach Orga $LesOrgas {
# set BelOrga [string range "$Orga..." 0 3]
set BelOrga $Orga
set PIO [PourcentageIdentiteOrga $PAB $Orga]
if {$PIO == -1} {
set Oo [string tolower $BelOrga]
} elseif {$PIO >= 20} {
set Oo [string toupper $BelOrga]
} else {
set Oo [string tolower $BelOrga]
set Oo [string replace $Oo 0 0 [string toupper [string range $Oo 0 0]]]
}
lappend LesOos $Oo
}
set Oos($PAB) [join $LesOos " "]
AppendAuFichier $FichierOos "$PAB [set Oos($PAB)]"
}
}
set Oos("EstCharge") 1
}
if {$Nom!=""} {
if {[info exists Oos($Nom)]} {
set Retour [set Oos($Nom)]
if {$Etat=="Names"} {
if {[info exists Oos("Names")]} { return [set Oos("Names")] }
set Oos("Names") [VerticalNames $Retour]
return [set Oos("Names")]
}
if {$Etat=="StarsP"} {
regsub -all {\.} $Retour "" Retour
append Retour "/"
regsub -all { +} $Retour "/" Retour
regsub -all {[A-Z][a-z]+} $Retour "*" Retour
regsub -all {[A-Z]+/} $Retour "*" Retour
regsub -all {[a-z]+/} $Retour " " Retour
regsub -all {/+} $Retour "" Retour
regsub -all {\*} $Retour "X" Retour
}
if {$Etat=="Stars"} {
regsub -all {\.} $Retour "" Retour
append Retour "/"
regsub -all { +} $Retour "/" Retour
regsub -all {[A-Z]+/} $Retour "*" Retour
regsub -all {[A-Za-z]+} $Retour " " Retour
regsub -all {/+} $Retour "" Retour
regsub -all {\*} $Retour "A" Retour
}
if {$Etat=="Presents"} { regsub -all {[A-Z][a-z][a-z\.]+|[a-z][a-z\.]+} $Retour " " Retour }
if {$Etat=="Hesitants"} { regsub -all {[A-Z][A-Z\.]+|^[a-z\.]+} $Retour " " Retour }
if {$Etat=="Hesitants"} { regsub -all { [a-z\.]+} $Retour " " Retour }
if {$Etat=="Absents"} { regsub -all {[A-Z][A-Za-z\.]+} $Retour " " Retour }
return $Retour
} else {
return ""
}
}
}
proc ORGAorgaDesOperons {{Nom ""} {Etat ""}} {
global OosO Oos
global RepertoireDuGenome
global NotreOS
global NotreOrga
Wup "Create fiches/oooperon if necessary"
set CreerDeTouteFacon 0
if {$Nom=="CreateIt"} {
set CreerDeTouteFacon 1
if {[info exists OosO("EstCharge")]} { unset OosO }
}
if {[info exists OosO("EstCharge")] && $Nom=="" && [set OosO("EstCharge")]=="ORGAorgaNonValide"} {
return "ORGAorgaNonValide"
}
set FichierOos "$RepertoireDuGenome/fiches/oooperon"
if { ! [info exists OosO("EstCharge")]} {
if {[file exists $FichierOos] && ! $CreerDeTouteFacon} {
foreach Ligne [LesLignesDuFichier $FichierOos] {
scan $Ligne "%s" PAB
regsub "$PAB " $Ligne "" Reste
set OosO($PAB) $Reste
}
set OosO("EstCharge") 1
}
}
if { ! [info exists OosO("EstCharge")]} {
set LesNomOos {}
if {[ListeDesOrganismesAyantMemeOperon "est-il-valide"]=="OrganismesAyantMemeOperonNonValide"} {
set OosO("EstCharge") "ORGAorgaNonValide"
return "ORGAorgaNonValide"
} else {
if { $CreerDeTouteFacon || \
[OuiOuNon " Do I create \n$FichierOos\n ... It would take a while ... ?" 0]} {
if {[file exists $FichierOos]} {
if {[OuiOuNon "$FichierOos\n already exists. Do I replace it ?" 0]} {
File delete $FichierOos
} else {
if {[OuiOuNon "Do I append to it ? "]} {
foreach Ligne [LesLignesDuFichier $FichierOos] {
scan $Ligne "%s" PAB
regsub "$PAB " $Ligne "" Reste
set OosO($PAB) $Reste
set DejaVu($PAB) 1
}
} else {
if {[OuiOuNon "Do I cancel ?"]} { return "" } else { }
}
}
}
} else {
set OosO("EstCharge") "ORGAorgaNonValide"
return "ORGAorgaNonValide"
}
set LesOrgas {}
foreach Complet [LesGenomesDansLeBonOrdre] {
lappend LesOrgas [Glossaire $Complet Court]
}
foreach PAB [ListeDesPABs] {
if {[info exists DejaVu($PAB)]} { continue }
set LesOMOs [ListeDesOrganismesAyantMemeOperon $PAB]
set LesOos {}
foreach Orga $LesOrgas {
set BelOrga $Orga
set YEst [lsearch -exact $LesOMOs $Orga]
if {$YEst < 0} {
set Oo [string tolower $BelOrga]
} else {
set Oo [string toupper $BelOrga]
}
lappend LesOos $Oo
}
set OosO($PAB) [join $LesOos " "]
AppendAuFichier $FichierOos "$PAB [set OosO($PAB)]"
}
}
set OosO("EstCharge") 1
}
if {$Nom!=""} {
if {[info exists OosO($Nom)]} {
set Retour [set OosO($Nom)]
if {$Etat=="Names"} {
if {[info exists Oos("Names")]} { return [set Oos("Names")] }
set Oos("Names") [VerticalNames $Retour]
return [set Oos("Names")]
}
if {$Etat=="Stars"} {
regsub -all {\.} $Retour "" Retour
append Retour "/"
regsub -all { +} $Retour "/" Retour
regsub -all {[A-Z]+/} $Retour "*" Retour
regsub -all {[A-Za-z]+} $Retour " " Retour
regsub -all {/+} $Retour "" Retour
regsub -all {\*} $Retour "O" Retour
}
return $Retour
} else {
return ""
}
}
}
proc SauteSurCible {K x y} {
global RepertoireDuGenome
global yDuContig
set Id [$K find withtag current]
set QueryFraction [lindex [$K gettags $Id] 0]
scan $QueryFraction "%s %s" Contig Fraction
set CibleEtc [lindex [$K gettags $Id] 1]
scan $CibleEtc "%s" Cible
set y [set yDuContig($Cible)]
$K yview moveto $y
$K yview scroll -5 units
}
proc AfficheLeBlastNDuContig {K x y} {
global RepertoireDuGenome
set Id [$K find withtag current]
set QueryFraction [lindex [$K gettags $Id] 0]
scan $QueryFraction "%s %s" Contig Fraction
set w [AfficheFichier "$RepertoireDuGenome/blastn/TTH-$Contig" "AvecRien"]
Illumine $Fraction $w
}
proc TopoDuBlastN {} {
global RepertoireDuGenome
global PlottePourBlastN
global DotPlotDesProches ; set DotPlotDesProches 0
global yDuContig
set OnVeutLeDotPlot 0
set OnVeutLesQuery 1
foreach Ligne [LesLignesDuFichier "$RepertoireDuGenome/fiches/bornesdescontigs"] {
scan $Ligne "%s %d %d" Contig d f
set Debut($Contig) $d
set Fin($Contig) $f
set Long($Contig) [expr $f-$d+1]
lappend LesFins $f
set ContigDeLaFin($f) $Contig
}
set OldContig ""
foreach Ligne [LesLignesDuFichier "$RepertoireDuGenome/fiches/ouonttapelescontigs.mini"] {
if { ! [regexp {[a-z0-9]} $Ligne]} { continue }
scan $Ligne "%s %d %d %s %s %s %s %d %d %d %d" Contig a b OrgaComplet Orga Fraction PN dQ fQ dC fC
regsub {TTH\-} $Contig "" Contig
set Sens "F"
if {$dC>$fC} {
set W $dC
set dC $fC
set fC $W
set Sens "R"
}
foreach FinDeContig $LesFins {
if {$FinDeContig < $fC} { continue }
set ContigCible [set ContigDeLaFin($FinDeContig)]
if {$dC < [set Debut($ContigCible)]} { FaireLire "A cheval sur $ContigCible\n$Ligne" }
break
}
ScanLaListe [split $Fraction "/"] IdenHSP LongHSP
if {$LongHSP < 1} { continue }
set Limite -0
if {[incr dQ $Limite]<0} { continue }
if {[incr fQ $Limite]<0} { continue }
if {[incr dC $Limite]<0} { continue }
if {[incr fC $Limite]<0} { continue }
lappend Nous "$Contig $dQ $fQ"
lappend Nous "$Contig $dQ $fQ"
lappend Vous "$ContigCible $dC $fC"
lappend Vous "$ContigCible $dC $fC"
lappend NosPos $dQ
lappend NosPos $fQ
lappend VosPos $dC
lappend VosPos $fC
set dQr [format "%3d" [expr round(100.*($dQ-[set Debut($Contig)])/[set Long($Contig)])] ]
set fQr [format "%3d" [expr round(100.*($fQ-[set Debut($Contig)])/[set Long($Contig)])] ]
set dCr [format "%3d" [expr round(100.*($dC-[set Debut($ContigCible)])/[set Long($ContigCible)])] ]
set fCr [format "%3d" [expr round(100.*($fC-[set Debut($ContigCible)])/[set Long($ContigCible)])] ]
set BelleFraction [format "%15s" $Fraction]
set OldContig $Contig
set Resume "$Sens $Contig $dQr $fQr $ContigCible $dCr $fCr $BelleFraction $dQ $fQ [set Debut($Contig)] [set Long($Contig)] $dC $fC [set Debut($ContigCible)] [set Long($ContigCible)]"
lappend LesCommunsDeCible($ContigCible) $Resume
lappend LesCommunsDeQuery($Contig) $Resume
}
set xMax 12000
set yMax 250000
set K [UnCanva $xMax $yMax 1000 1000]
MainLeveeSurUnCanva $K
set dy 50
set y [expr 10*$dy]
set lQueryMax 0
foreach Contig [lsort -decreasing [array names LesCommunsDeCible]] {
set lQuery 0
set MettreEntete 1
foreach Ligne [set LesCommunsDeQuery($Contig)] {
scan $Ligne "%s %s %d %d %s %d %d %s %d %d %d %d %d %d %d %d" Sens Query dQr fQr Cible dCr fCr Fraction dQ fQ aQ lQ dC fC aC lC
if { ! $lQuery } { set lQuery $lQ }
if { ! $lQueryMax } { set lQueryMax $lQ }
set oC [expr $lQueryMax+$dQ-$aQ-$dC+$aC]
incr y $dy
if {$Sens=="F"} {
set CouleurAuSens "red"
} else {
set CouleurAuSens "blue"
}
set X1 $oC
set X2 [expr $oC+$lC]
set X1 [expr $X1/24.]
set X2 [expr $X2/24.]
if {$MettreEntete} {
set MettreEntete 0
$K create text [expr $X1] [expr $y-2*$dy] -text $Contig -fill black -anchor w
set yDuContig($Query) [expr 1.*$y/$yMax]
set X2Query $X2
set n 0
lappend LesTextesAssocies ""
}
$K create line $X1 $y $X2 $y -fill black
set bdQ [format "%7d" $dQ]
set bfQ [format "%7d" $fQ]
set bdC [format "%7d" $dC]
set bfC [format "%7d" $fC]
set blQ [format "%7d" [set Long($Query)]]
set blC [format "%7d" [set Long($Cible)]]
set baQ [format "%7d" [set Debut($Query)]]
set bzQ [format "%7d" [set Fin($Query)]]
set baC [format "%7d" [set Debut($Cible)]]
set bzC [format "%7d" [set Fin($Cible)]]
set bFraction [format "%11s" $Fraction]
set BeauTexteQuery "$Query $bFraction $blQ $bdQ-$bfQ $baQ $bzQ"
set TexteQuery "$Query $Fraction [set Long($Query)] $dQ-$fQ [set Debut($Query)] [set Fin($Query)]"
set TexteCible "$Cible [string repeat " " [string length $Fraction]] [set Long($Cible)] $dC-$fC [set Debut($Cible)] [set Fin($Cible)]"
set BeauTexteCible "$Cible $blC $bdC-$bfC $baC $bzC"
set LesTags [list "$TexteQuery" "\n$TexteCible" "Coeur"]
set Texte [format "%2.2d %s" [incr n] $Cible]
$K create text [expr $X2Query+100] $y -text $Texte -anchor w -font {Courier 4}
lappend LesTextesAssocies "[format %2d $n] $BeauTexteQuery $BeauTexteCible"
set X1 [expr $oC+$dC-$aC]
set X2 [expr $oC+$fC-$aC]
set X1 [expr $X1/24.]
set X2 [expr $X2/24.]
$K create line $X1 $y $X2 $y -fill $CouleurAuSens -width 3 -tag $LesTags
}
incr y [expr 5*$dy]
$K create line 0 $y 24000 $y -fill grey
incr y [expr 5*$dy]
}
SauveLesLignes $LesTextesAssocies dans "$RepertoireDuGenome/textesassocies"
regsub {\.canvas} $K "" FK
Gonfle $FK all 0.2 0.2
BoutonneLaFenetre $FK "Coucou" "puts coucou"
$K bind "Coeur" <1> "AfficheLeBlastNDuContig $K %x %y"
$K bind "Coeur" <2> "SauteSurCible $K %x %y"
$K bind "Coeur" <Enter> "EntreDansCoeur $K %x %y"
$K bind "Coeur" <Leave> "SortDeCoeur $K %x %y"
if {$OnVeutLeDotPlot} {
set PlottePourBlastN 0
Plotte $Nous $Vous $NosPos $VosPos
unset PlottePourBlastN
}
}
proc TesteRepereBox K {
LesOrdresPourGif [GscopeBoard titi PourGif]
exit
Espionne [RepereBox "serrs" OrdrePourGif]
}
proc TrogStatus Nom {
global RepertoireDuGenome
global TrogStatus
if {[info exists TrogStatus($Nom)]} { return [set TrogStatus($Nom)] }
if {[info exists TrogStatus("EstCharge")]} { return "" }
set FichierTrogStatus "$RepertoireDuGenome/fiches/trogstatus"
set TrogStatus("EstCharge") "EstCharge"
if { ! [file exists $FichierTrogStatus]} { return "" }
foreach Ligne [LesLignesDuFichier $FichierTrogStatus] {
scan $Ligne "%s %s" NomLu Valeur
set TrogStatus($NomLu) $Valeur
}
return [TrogStatus $Nom]
}
proc Sock {} {
return "Coucou\n[BoutADN 1 10 "F"]\nBeau bout de sequence."
}
proc PointeDotPlot {K X Y} {
global RepertoireDuGenome
set Contig "InconnuBlaBlaBla"
set Id [$K find withtag current]
set Moi [lindex [$K gettags $Id] 0]
set Toi [lindex [$K gettags $Id] 1]
scan $Moi "%d %d %s" MonD MonF Contig
scan $Toi "%d %d" TonD TonF
if { ! [file exists "$RepertoireDuGenome/blastn/$Contig"]} { return "" }
set Fenetre [AfficheFichier "$RepertoireDuGenome/blastn/$Contig" "SansFetch"]
Illumine $MonD $Fenetre
return $Fenetre
set MonO [FouR $MonD $MonF]
set TonO [FouR $TonD $TonF]
set MaSeq [BoutADN [Mini $MonD $MonF] [Maxi $MonD $MonF] $MonO]
set TaSeq [BoutADN [Mini $TonD $TonF] [Maxi $TonD $TonF] $TonO]
return [EntreTexte "$MaSeq\n$TaSeq"]
}
proc CreeLaBanqueBlastPureSansTroncon {} {
global RepertoireDuGenome
global FichierSequenceADN
set TFA $FichierSequenceADN
if {[file exists "$TFA.pure"]} { set TFA "$TFA.pure" }
return [CreeUneBanqueBlast $TFA "$RepertoireDuGenome/banques/[PreFixe]"]
}
proc BlastNDesContigsPures {} {
global RepertoireDuGenome
global ADN TDN RAC
global NotreOS
set BanqueBlastN "$RepertoireDuGenome/banques/[PreFixe]"
if { ! [file exists "$BanqueBlastN.nhr"]} {
if {[OuiOuNon "Blastn database $BanqueBlastN doesn't exists.\n\
Do I create it ?"]} {
CreeLaBanqueBlastPureSansTroncon
} else {
return ""
}
}
set RepBlastN "$RepertoireDuGenome/blastn"
if { ! [file exists $RepBlastN]} { File mkdir $RepBlastN }
catch {unset ADN}
catch {unset TDN}
catch {unset RAC}
if { ! [info exists ADN]} { ChargeADNetTDNetRAC ".pure" }
set OnAttendLeDernierContigDejaTraite 0
set OnAttendLeDernierHomologueBon 0
set FichierOuOntTapeLesContigs "$RepertoireDuGenome/fiches/ouonttapelescontigs"
while {[file exists $FichierOuOntTapeLesContigs]} {
if {[OuiOuNon "$FichierOuOntTapeLesContigs\already exists.\nDo I replace it ?"]} {
File delete $FichierOuOntTapeLesContigs
break
}
if {[OuiOuNon "$FichierOuOntTapeLesContigs\already exists.\nDo I append to it ?"]} {
set DernierHomologueBon [lindex [LesLignesDuFichier $FichierOuOntTapeLesContigs] end]
scan $DernierHomologueBon "%s" DernierContigDejaTraite
set OnAttendLeDernierContigDejaTraite 1
set OnAttendLeDernierHomologueBon 0
Espionne $DernierContigDejaTraite
Espionne $DernierHomologueBon
break
}
if {[OuiOuNon "$FichierOuOntTapeLesContigs\already exists.\nDo I cancel ?"]} {
return ""
}
if {[OuiOuNon "$FichierOuOntTapeLesContigs\already exists.\nDo I stop ?"]} {
exit
}
}
NousAllonsAuBoulot
foreach Ligne [LesLignesDuFichier "$RepertoireDuGenome/fiches/bornesdescontigs"] {
scan $Ligne "%s %d %d" Contig Debut Fin
set Orient "F"
Espionne $Ligne
if {$OnAttendLeDernierContigDejaTraite && ! [regexp $Contig $DernierContigDejaTraite]} { continue }
set OnAttendLeDernierContigDejaTraite 0
set SeqNuc [BoutADN $Debut $Fin $Orient]
set TFA [SequenceFormatTFA $SeqNuc "$Contig $Debut $Fin $Orient" "nucbrut"]
set FichierTFA [Sauve $TFA dans $Contig]
set FichierBlastN "$RepBlastN/[PreFixe]-$Contig"
set CommandeBlast "blastall \
-p blastn \
-d $BanqueBlastN \
-i $FichierTFA \
-o $FichierBlastN \
-q -1 -F T -G 6 -E 1"
if { ! [file exists $FichierBlastN]} {
Espionne "BlastN de $FichierTFA sur $BanqueBlastN"
eval exec $CommandeBlast
Espionne " --------> resultat dans $FichierBlastN"
}
foreach Homo [LesHomologiesDuBlastN $FichierBlastN "" $BanqueBlastN] {
set lHomo [split $Homo "\t"]
set i -1
set Nom [lindex $lHomo [incr i]]
set nCops [lindex $lHomo [incr i]]
set nCopsSeq [lindex $lHomo [incr i]]
set BanqueId [lindex $lHomo [incr i]]
set OrgaHomo [lindex $lHomo [incr i]]
set Identities [lindex $lHomo [incr i]]
set Expect [lindex $lHomo [incr i]]
set DebutQuery [lindex $lHomo [incr i]]
set FinQuery [lindex $lHomo [incr i]]
set DebutSbjct [lindex $lHomo [incr i]]
set FinSbjct [lindex $lHomo [incr i]]
set SeqSbjct [lindex $lHomo [incr i]]
set DebutQuery [expr $DebutQuery + $Debut -1]
set FinQuery [expr $FinQuery + $Debut -1]
set Homologue "$Nom\t$nCops\t$nCopsSeq\t$BanqueId\t$OrgaHomo\t$Identities\t$Expect\t$DebutQuery\t$FinQuery\t$DebutSbjct\t$FinSbjct"
Espionne "$Nom\t$nCops\t$nCopsSeq\t$Identities\t$Expect\t$DebutQuery\t$FinQuery\t$DebutSbjct\t$FinSbjct"
if {$OnAttendLeDernierHomologueBon && $Homologue != $DernierHomologueBon} { continue }
set OnAttendLeDernierHomologueBon 0
lappend LesHomologues $Homologue
AppendAuFichier $FichierOuOntTapeLesContigs $Homologue
}
}
OnRevientDuBoulot
catch {unset ADN}
catch {unset TDN}
catch {unset RAC}
}
proc DotPlotDesInteressants Orga {
global RepertoireDuGenome
global DotPlotDesProches ; set DotPlotDesProches 0
global PlottePourBlastN
foreach Ligne [LesLignesDuFichier "$RepertoireDuGenome/blastn/$Orga.mesinteressants"] {
scan $Ligne "%s %d %d %s %s %d %d %s %d" MonNom MonD MonF MonO TonNom TonD TonF TonO PI
lappend Nous "$MonNom $MonD $MonF $MonO"
lappend Vous "$TonNom $TonD $TonF $TonO $PI"
if {$MonO=="R"} {
set Toto $MonD
set MonD $MonF
set MonF $Toto
}
if {$TonO=="R"} {
set Toto $TonD
set TonD $TonF
set TonF $Toto
}
lappend NosPos $MonD
lappend NosPos $MonF
lappend VosPos $TonD
lappend VosPos $TonF
}
set PlottePourBlastN 1
Plotte $NosPos $VosPos $NosPos $VosPos
unset PlottePourBlastN
}
proc AnalyseLeBlastN {Fichier {BanqueBlast ""}} {
global RepertoireDuGenome
if { ! [file exists $Fichier]} {
set FichierDeLOrga "$RepertoireDuGenome/blastn/[file tail $Fichier]"
if { ! [file exists $FichierDeLOrga]} {
FaireLire "Sorry, I can't find \n $Fichier \n nor \n $FichierDeLOrga"
return ""
}
set Fichier $FichierDeLOrga
}
CreeLesBornesDuBlastN $Fichier $BanqueBlast
LesZonesDuBlastNEnOverlap $Fichier
exit
}
proc LesZonesDuBlastNEnOverlap Fichier {
global RepertoireDuGenome
global LesORFsEnOverlap
global ListeDeBoites
set FichierTesBornes "$Fichier.tesbornes"
set FichierMesBornes "$Fichier.mesbornes"
set FichierMesOverlaps "$Fichier.mesoverlaps"
set FichierMesSolitaires "$Fichier.messolitaires"
set FichierMesConviviaux "$Fichier.mesconviviaux"
set FichierMesInteressants "$Fichier.mesinteressants"
foreach Ligne [LesLignesDuFichier $FichierTesBornes] {
ExtraireDe $Ligne Nom Debut Fin Orient
regsub "TaZone" $Nom "MaZone" MonNom
set TaZone($MonNom) $Ligne
}
foreach Ligne [LesLignesDuFichier $FichierMesBornes] {
ExtraireDe $Ligne Nom Debut Fin Orient
if {[info exists DejaVu($Debut,$Fin,$Orient)]} {
Espionne "DejaVu [set DejaVu($Debut,$Fin,$Orient)] $Nom"
continue
}
set Long [expr $Fin-$Debut+1]
if {$Long<1000} { continue }
set Frame [NomDeLaFrame [expr $Debut%3] $Orient]
set Boite $Nom
Box $Boite nom $Nom
Box $Boite orient $Orient
Box $Boite frame $Frame
Box $Boite debut $Debut
Box $Boite fin $Fin
Box $Boite long $Long
set DejaVu($Debut,$Fin,$Orient) $Nom
lappend ListeDeBoites $Boite
}
CalculeLesORFsEnOverlap
foreach Boite $ListeDeBoites {
set Nom [Box $Boite nom]
set Over [CalculeLesOverlapsDe $Nom]
if {$Over == ""} { continue }
if {[regexp "I am in" $Over]} {
set EstIn($Nom) 1
}
}
foreach Boite $ListeDeBoites {
set Nom [Box $Boite nom]
if {[info exists EstIn($Nom)]} { continue }
set Over [CalculeLesOverlapsDe $Nom]
lappend Interessants $Nom
if {$Over == ""} {
lappend Solitaires $Nom
continue
}
lappend Conviviaux $Nom
foreach Ligne [split $Over "\n"] {
if {[regexp "I contain" $Ligne]} { continue }
set Toi [StringApres " in " dans $Ligne]
if {[info exists EstIn($Toi)]} { continue }
set Longueur [IntegerApres "Overlap\:" dans $Ligne]
if {$Longueur<100} { continue }
if {[Box $Nom orient]!=[Box $Toi orient]} { continue }
if {[info exists DejaVu($Nom,$Toi)]} { continue }
set DejaVu($Toi,$Nom) 1
lappend MoiToi $Nom
lappend MoiToi $Toi
lappend MoiToi $Longueur
}
}
set OldMoi ""
foreach {Moi Toi Longueur} $MoiToi {
if {$OldMoi != $Moi } {
lappend SortieOverlaps "$Moi [Box $Moi debut] [Box $Moi fin] [Box $Moi orient]"
set LongMoi [expr [Box $Moi fin]-[Box $Moi debut]+1]
}
set OldMoi $Moi
set LongToi [expr [Box $Toi fin]-[Box $Toi debut]+1]
lappend SortieOverlaps "[string repeat " " [string length $Moi]] [Box $Toi debut] [Box $Toi fin] [Box $Toi orient] $Toi $LongMoi $LongToi $Longueur"
}
foreach Nom $Solitaires {
lappend SortieSolitaires "$Nom [Box $Nom debut] [Box $Nom fin] [Box $Nom orient] [set TaZone($Nom)]"
}
foreach Nom $Conviviaux {
lappend SortieConviviaux "$Nom [Box $Nom debut] [Box $Nom fin] [Box $Nom orient] [set TaZone($Nom)]"
}
foreach Nom $Interessants {
lappend SortieInteressants "$Nom [Box $Nom debut] [Box $Nom fin] [Box $Nom orient] [set TaZone($Nom)]"
}
Espionne [SauveLesLignes $SortieSolitaires dans $FichierMesSolitaires]
Espionne [SauveLesLignes $SortieConviviaux dans $FichierMesConviviaux]
Espionne [SauveLesLignes $SortieOverlaps dans $FichierMesOverlaps]
Espionne [SauveLesLignes $SortieInteressants dans $FichierMesInteressants]
exit
}
proc CreeLesBornesDuBlastN {Fichier {BanqueBlast ""}} {
set NS 0
set NQ 0
foreach Homo [LesHomologiesDuBlastN $Fichier "" $BanqueBlast] {
set lHomo [split $Homo "\t"]
set i -1
set Nom [lindex $lHomo [incr i]]
set nCops [lindex $lHomo [incr i]]
set nCopsSeq [lindex $lHomo [incr i]]
set BanqueId [lindex $lHomo [incr i]]
set OrgaHomo [lindex $lHomo [incr i]]
set Identities [lindex $lHomo [incr i]]
set Expect [lindex $lHomo [incr i]]
set DebutQuery [lindex $lHomo [incr i]]
set FinQuery [lindex $lHomo [incr i]]
set DebutSbjct [lindex $lHomo [incr i]]
set FinSbjct [lindex $lHomo [incr i]]
set SeqSbjct [lindex $lHomo [incr i]]
set LongSbjct [expr abs($FinSbjct-$DebutSbjct)+1]
if {$LongSbjct<1000} { continue }
regsub "/" $Identities " " IsurT
scan $IsurT "%d %d" I T
set PI [expr round(100.*$I/$T)]
if {$PI < 60.} { continue }
if {$DebutSbjct<=$FinSbjct} {
set DS $DebutSbjct
set FS $FinSbjct
set OS "F"
} else {
set DS $FinSbjct
set FS $DebutSbjct
set OS "R"
}
if {$DebutQuery<=$FinQuery} {
set DQ $DebutQuery
set FQ $FinQuery
set OQ "F"
} else {
set DQ $FinQuery
set FQ $DebutQuery
set OQ "R"
}
incr NS
set MaZone "MaZone[format "%4.4d" $NS]"
incr NQ
set TaZone "TaZone[format "%4.4d" $NQ]"
lappend MesBornes "$MaZone $DS $FS $OS $PI $TaZone"
lappend TesBornes "$TaZone $DQ $FQ $OQ $PI $MaZone"
}
Espionne [SauveLesLignes $MesBornes dans "$Fichier.mesbornes"]
Espionne [SauveLesLignes $TesBornes dans "$Fichier.tesbornes"]
}
proc BlastNDUnOrgaComplet {{FichierTFA ""}} {
global RepertoireDuGenome
Wup "We make blastn agains a non overlapping database of the in 100000 bases cutted dna"
if {$FichierTFA==""} {
FaireLire "Please browse for a TFA file"
set FichierTFA [ButineArborescence "All" "$RepertoireDuGenome/../"]
}
set AutreOrga [file tail $FichierTFA]
regsub {\.tfa$} $AutreOrga "" AutreOrga
set Orga [Glossaire $AutreOrga Court]
while {$Orga==""} {
FaireLire "I couldn't find the organism associated to $FichierTFA\n\Please help me."
set Orga [Entre ""]
set Orga [Glossaire $Orga Court]
if {$Orga == "" && [OuiOuNon "Do I cancel ?"]} { return "" }
}
set BanqueBlastN "$RepertoireDuGenome/banques/[PreFixe]overlap"
if { ! [file exists "$BanqueBlastN.nhr"]} {
if {[OuiOuNon "Blastn database $BanqueBlastN doesn't exists.\n\
Do I create it ?"]} {
CreeLaBanqueBlastN $BanqueBlastN
} else {
return ""
}
}
set RepBlastN "$RepertoireDuGenome/blastn"
if { ! [file exists $RepBlastN]} { File mkdir $RepBlastN }
set FichierBlastN "$RepBlastN/$Orga"
set FaireBlastN 1
if {[file exists $FichierBlastN]} {
if {[OuiOuNon "$FichierBlastN already exists. Do I use it ?"]} {
set FaireBlastN 0
} elseif { ! [OuiOuNon "$FichierBlastN already exists. Do I replace it ?"]} {
set FaireBlastN 1
} else {
set FichierBlastN [FichierPourSaveAs "$FichierBlastN"]
if {$FichierBlastN==""} { return "" }
set FaireBlastN 1
}
}
set AnalyseLeBlastN [OuiOuNon "Do I analyse the BlastN for overlaps ?"]
if {$FaireBlastN} {
set CommandeBlast "blastall \
-p blastn \
-d $BanqueBlastN \
-i $FichierTFA \
-o $FichierBlastN \
-q -1 -F F -G 6 -E 1"
set CommandeBlast [Entre $CommandeBlast]
if {$CommandeBlast==""} { return "" }
eval exec $CommandeBlast
}
if {[file exists $FichierBlastN]} {
AnalyseLeBlastN $FichierBlastN $BanqueBlastN
return [AfficheFichier $FichierBlastN "AvecGrapheAvecSegAlignementAvecAligneurs"]
} else {
FaireLire "I have a problem ... $FichierBlastN doesn't exist."
return ""
}
}
proc CreeLaBanqueBlastN {{FichierTFAs ""}} {
global RepertoireDuGenome
global NotreOS
set LongueurChevauchement 10000
set RepertoireBanquesBlast "$RepertoireDuGenome/banques"
if {$FichierTFAs==""} {
set FichierTFAs "$RepertoireBanquesBlast/[PreFixe]"
if {[OuiOuNon "Do we use (old manner) overlapping regions ?" 0]} {
append FichierTFAs "overlap"
}
}
set RepertoireTFAs [file dirname $FichierTFAs]
if {$RepertoireTFAs!=$RepertoireBanquesBlast} {
if {[OuiOuNon "$RepertoireTFAs\nis not the same as\n$RepertoireBanquesBlast\n\
Do I exit ?"]} { exit }
if {[OuiOuNon "Do I cancel ?"]} { return "" }
}
if { ! [file exists $RepertoireBanquesBlast]} { File mkdir $RepertoireBanquesBlast }
if { ! [file exists $FichierTFAs]} {
if {[OuiOuNon "The TFAs file \n$FichierTFAs\ndoesn't exist. Do I create it ?"]} {
while 1 {
if {[OuiOuNon "We do no more need to create overlapping regions.\n\
Ok to create a blastdatabase with the whole file ?"]} {
CreeFichierTFADuGenomePourBanqueBlast $FichierTFAs
break
}
if {[OuiOuNon "We do no more need to create overlapping regions.\n\
Ok to create a blastdatabase with overlapping regions ?" 0]} {
CreeTroncons "TFA" $FichierTFAs $LongueurChevauchement
break
}
if {[OuiOuNon "Do I cancel CreeLaBanqueBlastN ?" 0]} { return "" }
}
} else {
if {[OuiOuNon "Do I exit Gscope ?"]} { exit }
return ""
}
}
set NomDeLaBanque [file tail $FichierTFAs]
return [CreeUneBanqueBlast $FichierTFAs "$RepertoireBanquesBlast/$NomDeLaBanque"]
}
proc DotPlotBlastN {{Fichier ""} {BanqueBlast ""} } {
global RepertoireDuGenome
global DotPlotDesProches ; set DotPlotDesProches 0
global PlottePourBlastN
if {$Fichier==""} {
set LesHomologues [LesLignesDuFichier "$RepertoireDuGenome/fiches/ouonttapelescontigs"]
} else {
set LesHomologues [LesHomologiesDuBlastN $Fichier "" $BanqueBlast]
}
foreach Homo $LesHomologues {
set lHomo [split $Homo "\t"]
set i -1
set Nom [lindex $lHomo [incr i]]
set nCops [lindex $lHomo [incr i]]
set nCopsSeq [lindex $lHomo [incr i]]
set BanqueId [lindex $lHomo [incr i]]
set OrgaHomo [lindex $lHomo [incr i]]
set Identities [lindex $lHomo [incr i]]
set Expect [lindex $lHomo [incr i]]
set DebutQuery [lindex $lHomo [incr i]]
set FinQuery [lindex $lHomo [incr i]]
set DebutSbjct [lindex $lHomo [incr i]]
set FinSbjct [lindex $lHomo [incr i]]
set SeqQuery [lindex $lHomo [incr i]]
set SeqSbjct [lindex $lHomo [incr i]]
set LongSbjct [expr abs($FinSbjct-$DebutSbjct)+1]
if {$LongSbjct<100} { continue }
if {$DebutSbjct < $FinSbjct} {
set OrientSbjct "F"
} else {
set OrientSbjct "R"
}
if {$DebutQuery < $FinQuery} {
set OrientQuery "F"
} else {
set OrientQuery "R"
}
set TexteNous "$DebutSbjct $FinSbjct $Nom $OrientSbjct $OrientQuery $Identities"
set TexteVous "$DebutQuery $FinQuery"
regsub -all { +} $TexteNous " " TexteNous
regsub -all { +} $TexteVous " " TexteVous
lappend Nous $TexteNous
lappend Nous $TexteNous
lappend Vous $TexteVous
lappend Vous $TexteVous
lappend NosPos "$DebutSbjct"
lappend NosPos "$FinSbjct"
lappend VosPos "$DebutQuery"
lappend VosPos "$FinQuery"
}
set PlottePourBlastN 1
Plotte $Nous $Vous $NosPos $VosPos
unset PlottePourBlastN
}
proc LesHomologiesDuBlastN {Fichier {AvecLaSeq ""} {BanqueBlast ""} {Maniere ""} {Qui ""}} {
if {$Maniere==""} { set Maniere "AvecTestOrgaAvecOffset" }
set AvecTestOrga [string equal -nocase $Maniere "AvecTestOrga"]
set AvecOffset [string equal -nocase $Maniere "AvecOffset"]
if {$AvecLaSeq==""} { set AvecLaSeq "SansLaSeq" }
set AvecLaSeq [string equal -nocase $AvecLaSeq "AvecLaSeq"]
set Nom [file tail $Fichier]
set SeuilDuBlastN 0.001
set nSequencesTrouves [DecortiqueBlast $Fichier \
$SeuilDuBlastN "SansLimiteDeNombre" Query lBanqueId lAccess lDE lProfil lPN lPartieSegAli]
if { $nSequencesTrouves == 0 } {
set nCops 0
return {}
}
if {$Qui=="FirstOnly"} { set Qui [lindex $lBanqueId 0] }
set ListeDesHomologues {}
set nCops 0
set AttendreFinEntete 0
set FinEntete 0
foreach BanqueId $lBanqueId PN $lPN PartieSegAli $lPartieSegAli {
if {$Qui!="" && ! [string equal -nocase $Qui $BanqueId]} { continue }
if {$AvecTestOrga} {
set Genre ""
set Espece ""
scan [OffsetEtOrganismeDuFragment $BanqueId $BanqueBlast] "%s %s %s" O Genre Espece
set OrgaComplet "$Genre $Espece"
set Orga [Glossaire $OrgaComplet Court]
} else {
set Orga "iinc"
}
set nCopsDansCetteSequence 0
foreach Ligne $PartieSegAli {
if { $AttendreFinEntete } {
if { ! [regexp {[0-9a-zA-Z_]} $Ligne] } {
set AttendreFinEntete 0
set FinEntete 1
} else {
append Entete $Ligne
continue
}
}
if {[regexp {^>} $Ligne]} {
set Entete $Ligne
set AttendreFinEntete 1
}
if { $FinEntete } {
set FinEntete 0
if {$AvecOffset} {
set Offset [OffsetDansEnteteSegAli $Entete $BanqueBlast]
} else {
set Offset 0
}
}
if { [regexp "^ Identities =" $Ligne] } {
set Identities [StringApres "Identities =" dans $Ligne]
set Positives [StringApres "Positives =" dans $Ligne]
scan $Identities "%d/%d" nId nTotal
scan $Positives "%d/%d" nPo nTotal
}
if { [regexp "^ Score =" $Ligne] } {
if {[info exists Score]} {
incr nCops
incr nCopsDansCetteSequence
if { $AvecLaSeq } {
set EtLaSeq "\t$SeqQuery\t$SeqSbjct"
} else {
set EtLaSeq ""
}
Wup "Je triche en cachant dans Score le PourcentageIdentite"
set PourcentageIdentiteCacheDansScore [format "%5.2f" [expr (100.*$nId)/$nTotal]]
set BeauIdentities [format "%14.14s" $Identities]
lappend ListeDesHomologues "$Nom\t$nCops\t$nCopsDansCetteSequence\t$BanqueId\t$Orga\t$BeauIdentities\t$Expect\t$DebutQuery\t$FinQuery\t$DebutSbjct\t$FinSbjct$EtLaSeq"
unset Score
unset Expect
unset DebutQuery
unset DebutSbjct
}
set Score [FloatApres "Score =" dans $Ligne]
catch {unset Expect}
if {[regexp "Expect =" $Ligne]} {
set Expect [PNApres "Expect =" dans $Ligne]
}
if {[regexp {Expect\([0-9]\) =} $Ligne Match]} {
set Expect [PNApres $Match dans $Ligne]
}
if { ! [info exists Expect]} {
Warne "$Ligne\nwithout Expect ... I break"
catch {unset Score}
catch {unset Expect}
catch {unset DebutQuery}
catch {unset DebutSbjct}
break
}
catch {unset DebutQuery}
catch {unset DebutSbjct}
if { [expr $Expect > $SeuilDuBlastN]} {
catch {unset Score}
catch {unset Expect}
catch {unset DebutQuery}
catch {unset DebutSbjct}
break
}
}
if {[regexp "^ Database:" $Ligne] } {
break
}
if {[regexp "^Query:?" $Ligne] } {
if { ! [info exists DebutQuery]} {
set SeqQuery ""
#rR pour lire aussi les blast+ 2018/11/07
set Key "Query"
if {[regexp "Query:" $Ligne]} { set Key "Query:" }
set DebutQuery [IntegerApres $Key dans $Ligne]
}
regexp -indices {[0-9]+} $Ligne D
set D [lindex $D 1]
regexp -indices {[0-9]+} [string range $Ligne [incr D] end] F
set F [expr [lindex $F 0]+$D-1]
append SeqQuery [string trim [string range $Ligne $D $F]]
set FinQuery [IntegerEnFin de $Ligne]
}
if {[regexp "^Sbjct:?" $Ligne] } {
if { ! [info exists DebutSbjct]} {
set SeqSbjct ""
#rR pour lire aussi les blast+ 2018/11/07
set Key "Sbjct"
if {[regexp "Sbjct:" $Ligne]} { set Key "Sbjct:" }
set DebutSbjct [expr [IntegerApres $Key dans $Ligne] + $Offset]
}
regexp -indices {[0-9]+} $Ligne D
set D [lindex $D 1]
regexp -indices {[0-9]+} [string range $Ligne [incr D] end] F
set F [expr [lindex $F 0]+$D-1]
append SeqSbjct [string trim [string range $Ligne $D $F]]
set FinSbjct [expr [IntegerEnFin de $Ligne] + $Offset]
}
}
if {[info exists Score] && [expr $Expect <= $SeuilDuBlastN] } {
incr nCops
incr nCopsDansCetteSequence
if { $AvecLaSeq } {
set EtLaSeq "\t$SeqQuery\t$SeqSbjct"
} else {
set EtLaSeq ""
}
Wup "Je triche en cachant dans Score le PourcentageIdentite"
set PourcentageIdentiteCacheDansScore [expr (100.*$nId)/$nTotal]
lappend ListeDesHomologues "$Nom\t$nCops\t$nCopsDansCetteSequence\t$BanqueId\t$Orga\t$PourcentageIdentiteCacheDansScore\t$Expect\t$DebutQuery\t$FinQuery\t$DebutSbjct\t$FinSbjct$EtLaSeq"
}
catch {unset Score}
catch {unset Expect}
catch {unset DebutQuery}
catch {unset DebutSbjct}
if {$Qui!=""} { break }
}
return $ListeDesHomologues
}
proc CreeClasseDesOrganismes {} {
global RepertoireDuGenome
foreach Organisme [Glossaire Bidon Index] {
regsub "_" $Organisme " " Organisme
set Classe [OCduOS $Organisme]
if {$Classe=="ClassUnknown" && [regexp -nocase virus $Organisme]} { set Classe "Virus" }
lappend Sortie "$Organisme $Classe"
}
Espionne [SauveLesLignes $Sortie dans glossaire.classes.arenommer]
}
proc ContigDuPAB Nom {
global RepertoireDuGenome
global ContigDuPAB
global ListeDeBoites
if { ! [info exists ListeDeBoites]} { ChargeListeDeBoites }
if {[info exists ContigDuPAB($Nom)]} { return [set ContigDuPAB($Nom)] }
if {[info exists ContigDuPAB("EstCharge")]} { return 0 }
set FichierBornesDesContigs "$RepertoireDuGenome/fiches/bornesdescontigs"
set ContigDuPAB("EstCharge") "EstCharge"
if { ! [file exists $FichierBornesDesContigs]} {
return 0
} else {
foreach Ligne [LesLignesDuFichier $FichierBornesDesContigs] {
scan $Ligne "%s %s %s" Contig Debut Fin
lappend LesDebuts $Debut
lappend LesFins $Fin
set Contigs($Debut) $Contig
set Fins($Debut) $Fin
}
foreach Boite $ListeDeBoites {
set NomLu [Box $Boite nom]
set Debut [Box $Boite debut]
set Fin [Box $Boite fin]
set Orient [Box $Boite orient]
foreach DC $LesDebuts {
if { $Debut < $DC } { continue }
set ContigDuPAB($NomLu) "[set Contigs($DC)] $DC [set Fins($DC)]"
}
}
return [ContigDuPAB $Nom]
}
}
proc ConcateneLesContigs {{FichierACreer ""} {NomDeBapteme ""}} {
global RepertoireDuGenome
if {$FichierACreer==""} {
FaireLire "Please give me the name of the DNA sequence file."
set FichierACreer [FichierPourSaveAs "$RepertoireDuGenome/beton/allcontigs.tfa"]
}
if {$FichierACreer==""} { return "" }
if {$NomDeBapteme==""} { set NomDeBapteme "DNAsequence" }
set Tout ""
set ToutPure ""
set NumeroContig 0
set FinContig 0
foreach FichierContig [glob "$RepertoireDuGenome/contigs/*"] {
incr NumeroContig
set LigneKO 0
set Contig ""
foreach Ligne [LesLignesDuFichier $FichierContig] {
regsub -all -nocase "X" $Ligne "N" Ligne
if {[regexp -nocase {[^ATGCNMKRSYWVHDB ]} $Ligne Match]} {
if {[OuiOuNon "In file $FichierContig a line contiains\n $Match\nwhich is unusual. \
Do I skipp this file"]} { set LigneKO 1 ; break }
if {[OuiOuNon "Do I skipp this line ?"]} { continue }
if {[OuiOuNon "Do I remove the wrong characters ?"]} {
regsub -nocase {[^ATGCNMKRSYWVHDB]} $Ligne] "" Ligne
}
if {[OuiOuNon "Do I replace the wrong characters with 'n' ?"]} {
regsub -nocase {[^ATGCNMKRSYWVHDB]} $Ligne] "n" Ligne
}
}
if {$LigneKO } { continue }
regsub " " $Ligne "" Ligne
append Contig $Ligne
}
set PotStart "TTAnTTAnTTATGnATGnATG"
set TratStop "CATnCATnCATAAnTAAnTAA"
set GrosContig "$PotStart$Contig$TratStop"
set Tout "$Tout$GrosContig"
set PotStartPure "nnnnnnnnnnnnnnnnnnnnn"
set TratStopPure "nnnnnnnnnnnnnnnnnnnnn"
set GrosContigPure "$PotStartPure$Contig$TratStopPure"
set ToutPure "$ToutPure$GrosContigPure"
set DebutContig [expr $FinContig+1]
set FinContig [string length $Tout]
lappend LesBornesDesContigs "CONTIG[format "%4.4d" $NumeroContig] $DebutContig $FinContig"
}
Espionne [SauveLesLignes $LesBornesDesContigs dans "$RepertoireDuGenome/fiches/bornesdescontigs"]
set Sequence [SequenceFormatTFA $Tout $NomDeBapteme "nucbrut"]
set SequencePure [SequenceFormatTFA $ToutPure $NomDeBapteme.pure "nucbrut"]
set NomDuFichierCree [Sauve $Sequence dans $FichierACreer]
set NomDuFichierCreePure [Sauve $SequencePure dans $FichierACreer.pure]
return $NomDuFichierCree
return $NomDuFichierCreePure
}
proc AfficheTexte {Texte {Titre ""} {X ""} {Y ""} } {
set w [NomDe fenetre]
toplevel $w
if {$Titre==""} { set Titre [string range $Texte 0 19] }
wm title $w $Titre
wm iconname $w $Titre
set LesLignesDuTexte [split $Texte "\n"]
set PremiereLigne [lindex $LesLignesDuTexte 0]
set Hauteur [Mini 12 [Maxi 30 [llength $LesLignesDuTexte]]]
set Largeur 80
foreach Ligne $LesLignesDuTexte {
set Largeur [Maxi $Largeur [string length $Ligne]]
}
set Largeur [Mini $Largeur 180]
text $w.text -wrap none -relief sunken -bd 2 \
-xscrollcommand "$w.scrollx set" -setgrid 1 \
-yscrollcommand "$w.scrolly set" -setgrid 1 \
-width $Largeur -height $Hauteur
$w.text insert 0.0 $Texte
$w.text configure -state "disable"
focus $w.text
frame $w.buttons
pack $w.buttons -side bottom -fill x -pady 2m
button $w.buttons.dismiss -background red -text "Dismiss" -command "destroy $w"
pack $w.buttons.dismiss -side left -expand 1
button $w.buttons.saveas -text "Save All/Sel."
bind $w.buttons.saveas <1> "SaveAs \[$w.text get 1.0 end\]"
bind $w.buttons.saveas <2> "SaveAs \[$w.text get sel.first sel.last\]"
pack $w.buttons.saveas -side left -expand 1
button $w.buttons.medline -text "Medline"
bind $w.buttons.medline <1> "AfficheMedline \[$w.text get 1.0 end\]"
pack $w.buttons.medline -side left -expand 1
scrollbar $w.scrollx -command "$w.text xview" -orient "horizontal"
pack $w.scrollx -side bottom -fill x
scrollbar $w.scrolly -command "$w.text yview"
pack $w.scrolly -side right -fill y
pack $w.text -expand yes -fill both
if {$X!=""} {
$w.text xview scroll $X units
}
if {$Y!=""} {
$w.text yview scroll $Y units
}
return $w
}
proc EnMajuscule {Fichier {Action "toupper"}} {
foreach Ligne [LesLignesDuFichier $Fichier] {
lappend Sortie [string $Action $Ligne]
}
Espionne [SauveLesLignes $Sortie dans $Fichier.$Action]
exit
}
proc VecteurVRP AA {
global FichierGscopeVRP
global VecteurVRP
if {[info exists VecteurVRP($AA)]} { return [set VecteurVRP($AA)] }
if {[info exists VecteurVRP("EstCharge")]} { return [set VecteurVRP(*)] }
foreach Ligne [LesLignesDuFichier "$FichierGscopeVRP"] {
scan $Ligne "%s %f %f" A X Y
set VecteurVRP($A) "$X $Y"
}
set VecteurVRP("EstCharge") "0.0 0.0"
return [VecteurVRP $AA]]
}
proc TresseVRP {{FichierMSF ""} {FichierTresse ""} {Derive 0}} {
while { ! [file exists $FichierMSF]} {
if {$FichierMSF==""} {
FaireLire "Please, browse for a MSF file."
set FichierMSF [ButineArborescence "All" "[RepertoireDuGenome]/"]
} elseif {[regexp [ExpressionReguliereDesPABs] $FichierMSF]} {
set FichierMSF "[RepertoireDuGenome]/msf/$FichierMSF"
}
if {$FichierMSF==""} { return "" }
if { ! [file exists $FichierMSF]} {
if {[OuiOuNon "$FichierMSF\n doesn't exist. Do I skipp ?"]} { return "" }
set FichierMSF ""
}
}
if {$FichierTresse==""} {
FaireLire "Please, give a filename for output."
set FichierTresse [FichierPourSaveAs]
}
if {$FichierTresse==""} { return "" }
set NombreDeSequences [DecortiqueUnMSF $FichierMSF LesNomsDeSequences Sequences]
set Sortie {}
lappend Sortie "begin_object [string range [file tail $FichierMSF] end-5 end ]"
set Ieme 0
foreach Nom $LesNomsDeSequences {
incr Ieme
set Sequence [set Sequences($Nom)]
set Objet [format "%s%3.3d" "Seq" $Ieme]
set Couleur [Nuance3x8 [expr 1.0*$Ieme/$NombreDeSequences]]
scan $Couleur "%d %d %d" r g b
set CouleurPourO [expr ($r*256 + $g)*256 + $b]
lappend Sortie " colour $CouleurPourO"
set Trace "move"
set X 0.0
set Y 0.0
set Z 0.0
set dZ 1.0
foreach A [split $Sequence ""] {
set Z [expr $Z+$dZ]
scan [VecteurVRP $A] "%f %f" dX dY
set X [expr $X+$dX]
set Y [expr $Y+$dY]
if {$Derive} {
lappend Sortie "$Trace $X $Y $Z"
} else {
lappend Sortie "move 0.0 0.0 $Z"
lappend Sortie "line $dX $dY $Z"
}
set Trace "line"
}
# lappend Sortie "end"
# Espionne [set FichierCree [SauveLesLignes $Sortie dans ${FichierTresse}$Objet]]
# regsub "/groupes/poch" $FichierCree "/home" FichierCree
# lappend LesFichiersCrees "draw $FichierCree"
}
Espionne [SauveLesLignes $Sortie dans $FichierTresse]
# Espionne [SauveLesLignes $LesFichiersCrees dans $FichierTresse]
exit
}
proc CoGlimmer Nom {
global RepertoireDuGenome
global CoGlimmer
if {[info exists CoGlimmer($Nom)]} { return [set CoGlimmer($Nom)] }
if {[info exists CoGlimmer("EstCharge")]} { return [set CoGlimmer("EstCharge")] }
Wup "Si bornesdesglimmers est cache on ne fait pas CoGlimmer"
if { ! [file exists "$RepertoireDuGenome/fiches/bornesdesglimmers"]} {
set CoGlimmer("EstCharge") "IgnoreCoGlimmer"
return [set CoGlimmer("EstCharge")]
}
set FichierCoGlimmer "$RepertoireDuGenome/fiches/coglimmer"
while { ! [file exists $FichierCoGlimmer]} {
if {[OuiOuNon "Do I calculate overlaps with GLIMMER to create the file\n$FichierCoGlimmer\ ?"]} {
CreeCorrespondanceAvecGlimmer $FichierCoGlimmer
continue
}
if {[OuiOuNon "Do I ignore overlaps with GLIMMER ?"]} {
set CoGlimmer("EstCharge") "IgnoreCoGlimmer"
return [set CoGlimmer("EstCharge")]
}
if {[OuiOuNon "Do I exit ?"]} { exit }
}
foreach Ligne [LesLignesDuFichier $FichierCoGlimmer] {
scan $Ligne "%s %s %s" A Etat B
set CoGlimmer($A) "$Etat $B"
}
set CoGlimmer("EstCharge") "EstCharge"
return [CoGlimmer $Nom]
}
proc CreeCorrespondanceAvecGlimmer {{FichierCoGlimmer ""}} {
global RepertoireDuGenome
global LesORFsEnOverlap
global ListeDeBoites
if { ! [info exists ListeDeBoites] } { ChargeListeDeBoites }
if {$FichierCoGlimmer==""} { set FichierCoGlimmer "$RepertoireDuGenome/fiches/coglimmer" }
foreach Boite [concat [ListeDesGLIMMERs] [ListeDesPABs]] {
set Nom [Box $Boite nom]
set Debut [Box $Boite debut]
set Fin [Box $Boite fin]
set Orient [Box $Boite orient]
if {[regexp "GLIMMER" $Nom]} {
set GLI($Debut,$Fin,$Orient) $Nom
}
if {[YaPABenDebutDe $Nom]} {
set PAB($Debut,$Fin,$Orient) $Nom
}
}
CalculeLesORFsEnOverlap "AvecGLIMMER"
Espionne "debut array get LesORFsEnOverlap"
EspionneL [array get LesORFsEnOverlap]
Espionne "fin array get LesORFsEnOverlap"
set Sortie {}
FaireLire "coucou"
foreach Boite [concat [ListeDesGLIMMERs] [ListeDesPABs]] {
set Nom [Box $Boite nom]
set Debut [Box $Boite debut]
set Fin [Box $Boite fin]
set Orient [Box $Boite orient]
Espionne $Nom
if {[regexp "GLIMMER" $Nom]} {
if {[info exists PAB($Debut,$Fin,$Orient)]} {
lappend Sortie "$Nom is [set PAB($Debut,$Fin,$Orient)]"
} else {
Espionne "$Nom,$Debut,$Fin,$Orient"
if {[info exists LesORFsEnOverlap($Nom)]} {
set Touches {}
foreach Over [set LesORFsEnOverlap($Nom)] {
if { ! [YaPABenDebutDe $Over]} { continue }
if {$Orient != [Box $Over orient]} { continue }
if {[expr [Box $Over debut]%3] != [expr $Debut%3]} { continue }
lappend Touches "$Over"
}
if {$Touches!={}} { lappend Sortie "$Nom touches [join $Touches " "]" }
}
}
}
if {[YaPABenDebutDe $Nom]} {
if {[info exists GLI($Debut,$Fin,$Orient)]} {
lappend Sortie "$Nom is [set GLI($Debut,$Fin,$Orient)]"
} else {
Espionne "$Nom,$Debut,$Fin,$Orient"
if {[info exists LesORFsEnOverlap($Nom)]} {
set Touches {}
foreach Over [set LesORFsEnOverlap($Nom)] {
if { ! [regexp "GLIMMER" $Over]} { continue }
if {$Orient != [Box $Over orient]} { continue }
if {[expr [Box $Over debut]%3 != $Debut%3]} { continue }
lappend Touches "$Over"
}
if {$Touches!={}} { lappend Sortie "$Nom overlaps [join $Touches " "]" }
}
}
}
}
catch {unset LesORFsEnOverlap}
return [SauveLesLignes $Sortie dans $FichierCoGlimmer]
}
proc DotPlotADN {PosX PosY} {
global DotPlotDesProches
set DotPlotDesProches 0
set lX 512
set lY $lX
set F 50
set SeuilAffichage 50
set dX [expr $PosX-$lX]
set fX [expr $PosX+$lX]
set dY [expr $PosY-$lY]
set fY [expr $PosY+$lY]
for {set i $dX} {$i<$fX} {incr i} {
set SeqX [BoutADN [expr $i-$F] [expr $i+$F] "F"]
set LesX [split $SeqX ""]
for {set j $dY} {$j<$fY} {incr j} {
set SeqY [BoutADN [expr $j-$F] [expr $j+$F] "F"]
set LesY [split $SeqY ""]
set N 0
set Z 5
foreach X $LesX Y $LesY {
if {$X==$Y} {
incr N
set Z 5
} else {
incr Z -1
}
if {$Z} { continue }
break
}
set Score [expr ($N*100)/(2*$F+1)]
if {$Score > $SeuilAffichage } {
lappend Nous "$SeqX "
lappend Vous " $SeqY"
lappend NosPos $i
lappend VosPos $j
}
}
}
return [Plotte $Nous $Vous $NosPos $VosPos]
}
proc CreeGIF {} {
set K .toto
canvas $K -width 100 -height 200
$K create rectangle 20 20 40 50 -fill "red"
CanvaEnGIF $K "OnVeutTout" "[HomeRipp]/gigi.gif"
destroy $K
}
proc GscopeBoard {{Titre ""} {PourGif ""}} {
global RepertoireDuGenome
global ListeDeBoites
global ScaleCumuleDeGonfle OrigXCumuleDeGonfle OrigYCumuleDeGonfle
global ScrollRectangleOriginal IdScrollRectangle
global bVisuPepCurrentGenome bVisuBlastCurrentGenome bVisuMSFCurrentGenome
global CouleurDuFond
global KanvaCourant
global LesKanvasOuverts
global Org1 Org2
global LesOrdresPourGif
if {$Titre==""} { set Titre "GscopeBoard" }
Gs "Canvas"
if {$PourGif != ""} {
set PourGif 1
set Canvas NeRienFaire
set Bind NeRienFaire
set Pack NeRienFaire
set Fram NeRienFaire
set Button NeRienFaire
set Scrollbar NeRienFaire
set Grid NeRienFaire
set FonctionRejetteLaBoite "RejetteLaBoite"
set LesOrdresPourGif {}
set w "PourGif"
set K "OrdrePourGif"
} else {
set PourGif 0
set Canvas canvas
set Bind bind
set Pack pack
set Fram frame
set Button button
set Scrollbar scrollbar
set Grid grid
set FonctionRejetteLaBoite "NeRejettePasLaBoite"
set w [NomDe board]
catch {destroy $w}
toplevel $w
wm title $w "$Titre"
wm iconname $w "$Titre"
set K $w.canvas
JeMeSignale "Patience"
}
if { ! [info exists ListeDeBoites] } { ChargeListeDeBoites }
set ScroHor $w.hscroll
set ScroVer $w.vscroll
set KShSv $w.grid
set Boutons $w.buttons
set Clavier $w.buttons
scan [BoundingBox $ListeDeBoites] "%d %d" xDebut xFin
set xDebut [Maxi 0 [expr $xDebut-3000]]
incr xFin 1000
set CanvaSizeX [expr $xFin - $xDebut]
set CanvaScroMinX [expr $xDebut]
set CanvaScroMaxX [expr $xFin ]
set CanvaScreenX 1024
set TxtCenX 0
set BoxMinY -20
set BoxMaxY 20
set DeltaY [expr 0.9*($BoxMaxY-$BoxMinY)]
set BordHaut [expr 1.5*($BoxMaxY-$BoxMinY)]
set EcraseLaFrame(a) 0.8
set EcraseLaFrame(b) 0.8
set EcraseLaFrame(c) 0.8
set EcraseLaFrame(A) 0.8
set EcraseLaFrame(B) 0.8
set EcraseLaFrame(C) 0.8
set EcraseLaFrame(T) 1.0
set EcraseLaFrame(N) 0.7
set EcraseLaFrame(Z) 1.0
set EcraseLaFrame(n) 0.7
set EcraseLaFrame(t) 1.0
set EcraseLaFrame(D) 0.8
set EcraseLaFrame(E) 0.8
set EcraseLaFrame(F) 0.8
set EcraseLaFrame(d) 0.8
set EcraseLaFrame(e) 0.8
set EcraseLaFrame(f) 0.8
set PositionDeLaFrame(a) [expr $BordHaut + 0.0*$DeltaY]
set PositionDeLaFrame(b) [expr $BordHaut + 1.0*$DeltaY]
set PositionDeLaFrame(c) [expr $BordHaut + 2.0*$DeltaY]
set PositionDeLaFrame(A) [expr $BordHaut + 0.5*$DeltaY]
set PositionDeLaFrame(B) [expr $BordHaut + 1.5*$DeltaY]
set PositionDeLaFrame(C) [expr $BordHaut + 2.5*$DeltaY]
set PositionDeLaFrame(T) [expr $BordHaut + 3.0*$DeltaY]
set PositionDeLaFrame(N) [expr $BordHaut + 3.2*$DeltaY]
set PositionDeLaFrame(Z) [expr $BordHaut + 3.5*$DeltaY]
set PositionDeLaFrame(n) [expr $BordHaut + 3.8*$DeltaY]
set PositionDeLaFrame(t) [expr $BordHaut + 4.0*$DeltaY]
set PositionDeLaFrame(D) [expr $BordHaut + 5.5*$DeltaY]
set PositionDeLaFrame(E) [expr $BordHaut + 6.5*$DeltaY]
set PositionDeLaFrame(F) [expr $BordHaut + 7.5*$DeltaY]
set PositionDeLaFrame(d) [expr $BordHaut + 5.0*$DeltaY]
set PositionDeLaFrame(e) [expr $BordHaut + 6.0*$DeltaY]
set PositionDeLaFrame(f) [expr $BordHaut + 7.0*$DeltaY]
if {[OnTraiteUnGenome]} {
set PositionDuSpectre [expr $BordHaut + 9.0*$DeltaY]
set PosLineY [expr ($PositionDeLaFrame(a)+$PositionDeLaFrame(f))/2]
} else {
set PositionDuSpectre [expr $BordHaut + 2.0*$DeltaY]
}
set TxtCenY 0
set PosSecheLingeMinY 10
set PosSecheLingeMaxY 30
# set yHaut [expr $PositionDeLaFrame(a)-2*$BoxMinY]
# set yBas [expr $PositionDeLaFrame(f)+2*$BoxMaxY]
# set CanvaSizeY [expr $yBas-$yHaut]
# set CanvaScroMinY [expr $yHaut - 0.1*$CanvaSizeY]
# set CanvaScroMaxY [expr $yBas + 0.1*$CanvaSizeY]
set CanvaScroMinY 0
set CanvaScroMaxY [expr $PositionDuSpectre + 1.2*$DeltaY]
set CanvaScreenY [expr $CanvaScroMaxY-$CanvaScroMinY]
set CanvaSizeY $CanvaScreenY
$Fram $Boutons
$Pack $Boutons -side bottom -fill x -pady 2m
TouchePour $Clavier NouvelleGamme
TouchePour $Clavier NouvelleCouleur "red"
set ToucheDismiss [TouchePour $Clavier "Dismiss" "DetruireLeBoard $w"]
$Bind $ToucheDismiss <Control-2> "MainLeveeSurUnCanva $K"
TouchePour $Clavier NouvelleGamme
TouchePour $Clavier NouvelleCouleur "lightgrey"
TouchePour $Clavier "Zoom" "Gonfle $w all "
TouchePour <2> "/UnZoom" "Gonfle $w all degonfle"
TouchePour <3> "/Reset" "Gonfle $w all reset reset"
if { ! [PourWscope]} {
TouchePour $Clavier "Vis PNG" "CanvaEnPNG $K Visible AskForFile"
TouchePour <2> "/Postscr" "CanvaEnPostscript $K Visible AskForFile"
TouchePour <3> "/print" "CanvaEnImpression $K Visible"
TouchePour $Clavier "All PNG" "CanvaEnPNG $K OnVeutTout AskForFile"
TouchePour <2> "/Postscr" "CanvaEnPostscript $K OnVeutTout AskForFile"
TouchePour <3> "/print" "CanvaEnImpression $K OnVeutTout"
}
TouchePour $Clavier NouvelleGamme
TouchePour $Clavier NouvelleCouleur "yellow"
TouchePour $Clavier "Color ORFs" "RedefinirLaCouleur $K"
TouchePour <2> "/Banner" "RedefinirLaCouleurDuLinge $K"
TouchePour <3> "/Which" "FaireLire \[SignificationLingeFrameFard $K\]"
TouchePour $Clavier "Colors display" "AfficheLesCouleursEtSignifications $K"
TouchePour <2> "/to file" "CreeLeFichierAssocieAuxCouleurs $K"
TouchePour <3> " /On enter" "RedefinirLeFard $K"
if { ! [PourWscope]} {
TouchePour $Clavier "Action ORF-Enter" "ShowBoxAction Enter"
TouchePour <2> "/Clic" "ShowBoxAction Clic"
TouchePour <3> "/Show" "ShowBoxAction Which"
}
TouchePour $Clavier NouvelleGamme
TouchePour $Clavier NouvelleCouleur "green"
TouchePour $Clavier "Search" "RepereBox \[Entre \"Nom: [PreFixe]\"\] $K"
TouchePour <2> "/Next" "RepereBox Salut $K NextSansInforme"
TouchePour <3> "/Info" "RepereBox Salut $K Next"
TouchePour $Clavier "Nuc pos." "RepereNuc \[Entre \] $K"
TouchePour <2> " /sequence" "RepereNuc \[ChoixParmi \[LocaliseSurADN\]\]\" $K"
TouchePour <3> "/ Bird" "BirdGscopeSearch"
TouchePour $Clavier "Chromo" "IllustreLesChromosomes"
TouchePour <2> "/Histo" "ChoixHistogramme"
TouchePour <3> "/Narcisse" "RepereBox \"Nom: \[Narcisse \[Entre\]\]\" $K"
if { ! [PourWscope]} {
TouchePour $Clavier NouvelleGamme
TouchePour $Clavier NouvelleCouleur "lightgrey"
TouchePour $Clavier "Sel. to file" "Presente \[LesNomsPiques\]"
TouchePour <2> "/to disp" "Presente \[LesNomsPiques\]"
TouchePour <3> "/Reset" "Deselecte $K"
TouchePour $Clavier "Text font" "Scene $K toggle font"
TouchePour <2> "/color" "Scene $K toggle fill"
TouchePour $Clavier "Toggle text" "ToggleCanva $K TEXTE"
TouchePour <2> "/upper line" "ToggleCanva $K Linge"
}
if { ! [PourWscope]} {
TouchePour $Clavier NouvelleGamme
TouchePour $Clavier NouvelleCouleur "lightblue"
TouchePour $Clavier "Blast: X zone" "BlastXsurZone $K"
TouchePour <2> "/6P zone" "SixBlastPsurZone $K"
TouchePour <3> "/6P sel Prot" "SixBlastPsurPiques \[LesNomsPiques\]"
TouchePour $Clavier "Create DNA seq" "CreeLaSequenceDeLaZone $K"
TouchePour <2> "/Extend DNA" "VoisinADNDeLaZone $K"
TouchePour $Clavier "Create Family" "CreeLesFamillesDesSelectionnes"
}
# $Button $Boutons.liste -text "List\nTFA/Blast/MSF" \
# -background "green" -foreground "black"
# $Bind $Boutons.liste <1> "$bVisuPepCurrentGenome invoke"
# $Bind $Boutons.liste <2> "$bVisuBlastpCurrentGenome invoke"
# $Bind $Boutons.liste <3> "$bVisuMSFCurrentGenome invoke"
# $Pack $Boutons.liste -side left -expand 1
$Fram $KShSv
$Scrollbar $ScroHor -orient horiz -command "$K xview"
$Scrollbar $ScroVer -command "$K yview"
set BetterCanvaScroMaxY $CanvaScroMaxY
if {[OnTraiteDesClones]} { set BetterCanvaScroMaxY 3000 }
$Canvas $K -relief sunken -borderwidth 2 \
-width $CanvaScreenX \
-height $CanvaScreenY \
-scrollregion [list $CanvaScroMinX $CanvaScroMinY $CanvaScroMaxX $BetterCanvaScroMaxY] \
-xscrollcommand "$ScroHor set" \
-yscrollcommand "$ScroVer set"
$Pack $KShSv -expand yes -fill both -padx 1 -pady 1
$Grid rowconfig $KShSv 0 -weight 1 -minsize 0
$Grid columnconfig $KShSv 0 -weight 1 -minsize 0
$Grid $K -in $KShSv -padx 1 -pady 1 -row 0 -column 0 -rowspan 1 -columnspan 1 -sticky news
$Grid $ScroVer -in $KShSv -padx 1 -pady 1 -row 0 -column 1 -rowspan 1 -columnspan 1 -sticky news
$Grid $ScroHor -in $KShSv -padx 1 -pady 1 -row 1 -column 0 -rowspan 1 -columnspan 1 -sticky news
set CouleurDuFond "cadetblue"
$K configure -background $CouleurDuFond
set IdScrollRectangle($K) [$K create rectangle $CanvaScroMinX $CanvaScroMinY $CanvaScroMaxX $BetterCanvaScroMaxY -outline $CouleurDuFond -tag [list "Cadre"]]
set ScrollRectangleOriginal($K) "[$K coords [set IdScrollRectangle($K)]]"
if {[OnTraiteUnGenome]} {
$K create line $CanvaScroMinX $PosLineY $CanvaScroMaxX $PosLineY -fill "black"
}
set Patientons [$K create text 10 20 -text "Merci de patienter ... " -font {Courier 12} -anchor w]
if { ! $PourGif && ! [PourWscope] && [OnTraiteUnGenome]} {
AfficheLeSpectreGC $K [expr $PositionDuSpectre - $DeltaY] [expr $PositionDuSpectre + $DeltaY]
}
#rR set LesBoites [concat [ListeDesGLIMMERs] [ListeDesPABs] [ListeDesTRNAs] [ListeDesARNs] [ListeDesTROUs] [ListeDesFusions]]
set LesBoites [concat [ListeDesPABs] [ListeDesTRNAs] [ListeDesARNs] [ListeDesTROUs] [ListeDesFusions]]
foreach Boite $LesBoites {
if {[$FonctionRejetteLaBoite $Boite]} { continue }
set Nom [Box $Boite nom]
set Frame [Box $Boite frame]
set PosY [set PositionDeLaFrame($Frame)]
if {[OnTraiteDesClones]} {
set PosY [set PositionDeLaFrame(a)]
set DebFinOri "[Box $Boite deb]_[Box $Boite fin]_[Box $Boite ori]"
if { ! [info exists DejaPlace($DebFinOri)]} { set DejaPlace($DebFinOri) -1 }
set IemePosY [incr DejaPlace($DebFinOri)]
set PosY [expr $PosY + $IemePosY*0.9*($BoxMaxY-$BoxMinY)]
}
set PosMinY [expr $PosY + $BoxMinY*[set EcraseLaFrame($Frame)]]
set PosMaxY [expr $PosY + $BoxMaxY*[set EcraseLaFrame($Frame)]]
set PosTxtY [expr $PosY + $TxtCenY]
set PosMinX [Box $Boite debut]
set PosMaxX [Box $Boite fin]
set PosTxtX [expr ($PosMinX+$PosMaxX)/2 + $TxtCenX]
set Forme "rect"
if {[regexp "TROU" $Nom] && ! [PourWscope]} {
set Forme "oval"
}
if {[EstUneFusion $Nom]} { set Forme "oval" }
if {[Fantome $Nom]} {
set CouleurTrait "white"
} else {
set CouleurTrait "black"
}
if {[regexp "GLIMMER" $Nom]} {
if {[regexp "^is " [CoGlimmer $Nom]]} { continue }
set DecalageY 10
} else {
set GlimmerOK [regexp "^is " [CoGlimmer $Nom]]
set GlimmerNO [regexp "EstCharge" [CoGlimmer $Nom]]
set DecalageY 0
}
if {[YaPABenDebutDe $Nom] && $GlimmerNO} {
$K create $Forme $PosMinX $PosMinY $PosMaxX [expr $PosMaxY+$DecalageY+10] \
-fill "lightgrey" \
-outline "black" \
-tags [list "Box" "Fantome_$Boite" "FetchMe"]
}
$K create $Forme $PosMinX $PosMinY $PosMaxX [expr $PosMaxY+$DecalageY] \
-fill $CouleurDuFond \
-outline $CouleurTrait \
-tags [list "Box" "$Boite" "FetchMe"]
set TexteOrgAvant ""
set TexteOrgApres ""
if {0 && [YaPABenDebutDe $Nom] && ! [ExisteOrthologueDans $Org1 $Nom]} { set TexteOrgAvant "+ " }
if {0 && [YaPABenDebutDe $Nom] && ! [ExisteOrthologueDans $Org2 $Nom]} { set TexteOrgApres " +" }
if {1} {
$K create text $PosTxtX $PosTxtY \
-text "${TexteOrgAvant}[NomDeScene $Boite]${TexteOrgApres}" \
-fill $CouleurTrait \
-font {Courier 8} \
-anchor center \
-tags [list "TEXTE" "Txt_$Nom" "FetchMe" "DispMe"]
}
if {[regexp "GLIMMER" $Nom]} { continue }
$K create rectangle $PosMinX $PosSecheLingeMinY $PosMaxX $PosSecheLingeMaxY \
-tags [list "Linge" "Linge$Boite"]
}
Wup " ............................................et GscopeBoard crea les boites"
if { ! $PourGif } {
DefinirLaCouleurAuLancement $K
}
if {[OnTraiteUnGenome] && ! [PourWscope]} {
RelieLesOperons $K $PosLineY
}
$K delete $Patientons
if {[PourWscope]} {
$K bind "FetchMe" <1> "FetcheBox $K %x %y"
} else {
$K bind "DispMe" <Enter> "ShowBox $K %x %y Enter"
$K bind "DispMe" <Leave> "ShowBox $K %x %y Leave"
$K bind "Box" <Enter> "EnterBox $K %x %y"
$K bind "Box" <Leave> "LeaveBox $K %x %y"
$K bind "FetchMe" <1> "FetcheBox $K %x %y"
$K bind "FetchMe" <Shift-1> "FetcheBox $K %x %y MSF"
$K bind "FetchMe" <Control-1> "Informe \[NomDuCourant $K\]"
$Bind $K <2> "$K scan mark %x %y"
if {[OnTraiteDesCDNAs]} {
$K bind "Box" <2> "VoirLaMeilleureLocalisationDuCDNA \[NomDuCourant $K\]"
}
$Bind $K <B2-Motion> "$K scan dragto %x %y"
$K bind "Box" <Control-2> "SautParalogue $K %x %y"
$K bind "Box" <3> "PiqueBox $K %x %y Fixe"
$Bind $K <Shift-3> "ShowNuc $K %x %y Point"
$Bind $K <Shift-B3-Motion> "ShowNuc $K %x %y Motion"
}
if {$PourGif } { return $LesOrdresPourGif }
ShowBoxAction EnterDefaults
Gonfle $w all 0.1
set KanvaCourant $K
lappend LesKanvasOuverts $K
JeMeSignale "FinPatience"
if {0 && [PourWscope] } {
return $w
} else {
return $K
}
}
proc DecalageAngulaireRosace {} {
global DecalageAngulaireRosace
if {[info exists DecalageAngulaireRosace]} { return $DecalageAngulaireRosace }
if {[regexp "MsFinal" [RepertoireDuGenome]]} {
set StartGenome 5916072
set LongueurGenome 6988205
set DecalageAngulaireRosace [expr (1.*$StartGenome/$LongueurGenome)*2*3.14159]
} else {
set DecalageAngulaireRosace 0
}
return $DecalageAngulaireRosace
}
proc RscopeBoard {Titre {PourGif ""}} {
global RepertoireDuGenome
global ListeDeBoites
global ScaleCumuleDeGonfle OrigXCumuleDeGonfle OrigYCumuleDeGonfle
global ScrollRectangleOriginal IdScrollRectangle
global bVisuPepCurrentGenome bVisuBlastCurrentGenome bVisuMSFCurrentGenome
global CouleurDuFond
global KanvaCourant
global LesKanvasOuverts
global RosaceCourante
global Org1 Org2
global ParametresDuBoard
global FichierGscopeHublot
global LesOrdresPourGif
Gs "Canvas"
if {$PourGif != ""} {
set PourGif 1
set Canvas NeRienFaire
set Bind NeRienFaire
set Pack NeRienFaire
set Fram NeRienFaire
set Button NeRienFaire
set Scrollbar NeRienFaire
set Grid NeRienFaire
set FonctionRejetteLaBoite "RejetteLaBoite"
set LesOrdresPourGif {}
} else {
set PourGif 0
set Canvas canvas
set Bind bind
set Pack pack
set Fram frame
set Button button
set Scrollbar scrollbar
set Grid grid
set FonctionRejetteLaBoite "NeRejettePasLaBoite"
JeMeSignale "Patience"
}
if { ! [info exists ListeDeBoites] } { ChargeListeDeBoites }
if { ! $PourGif} {
set w [NomDe rond]
catch {destroy $w}
toplevel $w
wm title $w "$Titre"
wm iconname $w "$Titre"
set K $w.canvas
set CanvasizeX 800
set CanvasizeX 800
} else {
set w "PourGif"
set K "OrdrePourGif"
set CanvasizeX 256
}
scan [BoundingBox $ListeDeBoites] "%d %d" xDebut xFin
set CanvaScroMinX 0
set CanvaScroMaxX $CanvasizeX
set CanvasizeY $CanvasizeX
set CanvaScroMinY 0
set CanvaScroMaxY $CanvasizeY
set CanvascreenX $CanvasizeX
set CanvascreenY $CanvascreenX
set CentreX [expr $CanvascreenX/2]
set CentreY [expr $CanvascreenY/2]
set RayonMoyen [expr $CentreX*0.60]
set RayonMoyen [expr $CentreX*0.80]
set OffsetRayonMin [expr $RayonMoyen*0.02]
set OffsetRayonMax [expr $RayonMoyen*0.18]
set ScroHor $w.hscroll
set ScroVer $w.vscroll
set KShSv $w.grid
set Boutons $w.buttons
$Fram $Boutons
$Pack $Boutons -side bottom -fill x -pady 2m
$Button $Boutons.dismiss -text "Dismiss" -background red -command "DetruireLaRosace $w"
$Bind $Boutons.dismiss <Control-2> "MainLeveeSurUnCanva $K"
$Pack $Boutons.dismiss -side left -expand 1
$Button $Boutons.gonfle -text "Zoom/UnZoom/Desel\nJpg/Postscript/Print\nErase Sticks/Textes/Arcs"
$Bind $Boutons.gonfle <1> "Gonfle $w all gonfle gonfle"
$Bind $Boutons.gonfle <2> "Gonfle $w all degonfle degonfle"
$Bind $Boutons.gonfle <3> "Deselecte $K"
# $Bind $Boutons.gonfle <Shift-1> "ToggleCanva $K TEXTE"
# $Bind $Boutons.gonfle <Shift-1> "CanvaEnPNG $K"
$Bind $Boutons.gonfle <Shift-1> "CanvaEnJpg $K"
$Bind $Boutons.gonfle <Shift-2> "CanvaEnPostscript $K Visible AskForFile"
$Bind $Boutons.gonfle <Shift-3> "CanvaEnImpression $K Visible AskForFile"
$Bind $Boutons.gonfle <Control-1> "CleanRosace $K Aiguilles"
$Bind $Boutons.gonfle <Control-2> "CleanRosace $K Textes"
$Bind $Boutons.gonfle <Control-3> "CleanRosace $K Zones"
$Pack $Boutons.gonfle -side left -expand 1
$Button $Boutons.recolore \
-text "Color ORFs/Banner/Which\nColors display/to file/On enter\nAction ORF-Enter/Clic/Show" \
-background "yellow"
$Bind $Boutons.recolore <1> "RedefinirLaCouleur $K"
$Bind $Boutons.recolore <2> "RedefinirLaCouleurDuLinge $K"
$Bind $Boutons.recolore <3> "FaireLire \[SignificationLingeFrameFard $K\]"
$Bind $Boutons.recolore <Shift-1> "AfficheLesCouleursEtSignifications $K"
$Bind $Boutons.recolore <Shift-2> "CreeLeFichierAssocieAuxCouleurs $K"
$Bind $Boutons.recolore <Shift-3> "RedefinirLeFard $K"
if { ! [PourWscope]} {
$Bind $Boutons.recolore <Control-1> "ShowBoxAction Enter"
$Bind $Boutons.recolore <Control-2> "ShowBoxAction Clic"
$Bind $Boutons.recolore <Control-3> "ShowBoxAction Which"
}
$Pack $Boutons.recolore -side left -expand 1
$Button $Boutons.repere -text "Search/Next/Info\nNucleic\nNarcisse" -background "green"
$Bind $Boutons.repere <1> "RepereBox \[Entre \"Nom: [PreFixe]\"\] $K"
$Bind $Boutons.repere <Shift-1> "RepereNuc \[Entre \] $K"
$Bind $Boutons.repere <Control-1> "RepereBox \"Nom: \[Narcisse \[Entre\]\]\" $K"
$Bind $Boutons.repere <2> "RepereBox Salut $K NextSansInforme"
$Bind $Boutons.repere <3> "RepereBox Salut $K Next"
$Pack $Boutons.repere -side left -expand 1
$Button $Boutons.intero -text "Wheel Add/New/Which\nText Add/Save/Append\nfrom list/ /Erase"
$Bind $Boutons.intero <1> "InteRosace Add $K"
$Bind $Boutons.intero <2> "InteRosace New $K"
$Bind $Boutons.intero <3> "InteRosace Which $K"
$Bind $Boutons.intero <Shift-1> "TextePourRosace Add $K"
$Bind $Boutons.intero <Shift-2> "SauveLeCanva $K {Zone Fleche Etiquette}"
$Bind $Boutons.intero <Shift-3> "RestaureLeCanva $K ; BindLaRosace $K"
$Bind $Boutons.intero <Control-1> "TextePourRosace AddFromList $K "
$Bind $Boutons.intero <Control-2> ""
$Bind $Boutons.intero <Control-3> "TextePourRosace Erase $K"
$Pack $Boutons.intero -side left -expand 1
$Button $Boutons.rosarc -text "Wheel Turn+/Turn-/Switch\nText Add/Save/Append\nfrom list/ /Erase"
$Bind $Boutons.rosarc <1> "InteRosace Turn+ $K"
$Bind $Boutons.rosarc <2> "InteRosace Turn- $K"
$Bind $Boutons.rosarc <3> "InteRosace Switch $K"
$Bind $Boutons.rosarc <Shift-1> "TextePourRosace Add $K"
$Bind $Boutons.rosarc <Shift-2> "TextePourRosace Save $K"
$Bind $Boutons.rosarc <Shift-3> "TextePourRosace Append $K"
$Bind $Boutons.rosarc <Control-1> "TextePourRosace AddFromList $K "
$Bind $Boutons.rosarc <Control-2> ""
$Bind $Boutons.rosarc <Control-3> "TextePourRosace Erase $K"
# $Pack $Boutons.rosarc -side left -expand 1
$Button $Boutons.piques -text "Create FOF"
$Bind $Boutons.piques <1> "Presente \[LesNomsPiques\]"
# $Pack $Boutons.piques -side left -expand 1
$Button $Boutons.selnuc -text "Blast: X nuc zone/6P zone/ 6P sel Prot\nCreate DNA sequence/Extend DNA"
$Bind $Boutons.selnuc <1> "BlastXsurZone $K"
$Bind $Boutons.selnuc <2> "SixBlastPsurZone $K"
$Bind $Boutons.selnuc <3> "SixBlastPsurPiques \[LesNomsPiques\]"
$Bind $Boutons.selnuc <Shift-1> "CreeLaSequenceDeLaZone $K"
$Bind $Boutons.selnuc <Shift-2> "VoisinADNDeLaZone $K"
$Pack $Boutons.selnuc -side left -expand 1
$Fram $KShSv
$Scrollbar $ScroHor -orient horiz -command "$K xview"
$Scrollbar $ScroVer -command "$K yview"
$Canvas $K -relief sunken -borderwidth 2 \
-width $CanvascreenX \
-height $CanvascreenY \
-scrollregion [list $CanvaScroMinX $CanvaScroMinY $CanvaScroMaxX $CanvaScroMaxY] \
-xscrollcommand "$ScroHor set" \
-yscrollcommand "$ScroVer set"
$Pack $KShSv -expand yes -fill both -padx 1 -pady 1
$Grid rowconfig $KShSv 0 -weight 1 -minsize 0
$Grid columnconfig $KShSv 0 -weight 1 -minsize 0
$Grid $K -in $KShSv -padx 1 -pady 1 -row 0 -column 0 -rowspan 1 -columnspan 1 -sticky nsew
$Grid $ScroVer -in $KShSv -padx 1 -pady 1 -row 0 -column 1 -rowspan 1 -columnspan 1 -sticky nsew
$Grid $ScroHor -in $KShSv -padx 1 -pady 1 -row 1 -column 0 -rowspan 1 -columnspan 1 -sticky nsew
set CouleurDuFond "cadetblue"
if {[regexp "casimir" $RepertoireDuGenome]} {
set CouleurDuFond "white"
}
if {[regexp "MsFinal" $RepertoireDuGenome]} {
set CouleurDuFond "white"
}
$K configure -background $CouleurDuFond
set IdScrollRectangle($K) [$K create rectangle $CanvaScroMinX $CanvaScroMinY $CanvaScroMaxX $CanvaScroMaxY -outline $CouleurDuFond -tag [list "Cadre"]]
set ScrollRectangleOriginal($K) "[$K coords [set IdScrollRectangle($K)]]"
set ParametresDuBoard($K,xDdebut) $xDebut
set ParametresDuBoard($K,xFin) $xFin
set ParametresDuBoard($K,CentreX) $CentreX
set ParametresDuBoard($K,CentreY) $CentreY
set ParametresDuBoard($K,RayonMoyen) $RayonMoyen
set ParametresDuBoard($K,OffsetRayonMin) $OffsetRayonMin
set ParametresDuBoard($K,OffsetRayonMax) $OffsetRayonMax
if {0 && [info exists FichierGscopeHublot] && [file exists $FichierGscopeHublot]} {
image create photo Hublot -file $FichierGscopeHublot
$K create image $CentreX $CentreY -image Hublot -tags "Hublot"
}
foreach Boite $ListeDeBoites {
if {[regexp "GLIMMER" $Boite]} { continue }
if {[regexp "TROU" $Boite]} { continue }
set Nom [Box $Boite nom]
set Debut [Box $Boite debut]
set Fin [Box $Boite fin]
set Orient [Box $Boite orient]
set Milieu [expr ($Debut+$Fin)/2]
if {$Orient == "F"} {
set Sens 1
} else {
set Sens -1
}
if {[YaPABenDebutDe $Nom]} {
set RayonMin [expr $RayonMoyen + $Sens*$OffsetRayonMin]
set RayonMax [expr $RayonMoyen + $Sens*$OffsetRayonMax]
set LargeurDuTrait 1
} elseif {[regexp "TRNA" $Nom]} {
set RayonMin [expr $RayonMoyen - $OffsetRayonMin]
set RayonMax [expr $RayonMoyen + $OffsetRayonMin]
set LargeurDuTrait 2
} elseif {[regexp "ARN" $Nom]} {
set RayonMin [expr $RayonMoyen - $OffsetRayonMin]
set RayonMax [expr $RayonMoyen + $OffsetRayonMin]
set LargeurDuTrait 3
} else {
set RayonMin [expr $RayonMoyen - $OffsetRayonMin]
set RayonMax [expr $RayonMoyen + $OffsetRayonMin]
set LargeurDuTrait 1
}
set DecalageAngulaire [DecalageAngulaireRosace]
set Angle [expr $DecalageAngulaire + 3.14159/2 - $Milieu*2*3.14159/$xFin]
set PosMinX [expr $CentreX+$RayonMin*cos($Angle)]
set PosMinY [expr $CentreY-$RayonMin*sin($Angle)]
set PosMaxX [expr $CentreX+$RayonMax*cos($Angle)]
set PosMaxY [expr $CentreY-$RayonMax*sin($Angle)]
set Couleur $CouleurDuFond
if {[Fantome $Nom]} {
set CouleurTrait "white"
} else {
set CouleurTrait "black"
}
$K create line $PosMinX $PosMinY $PosMaxX $PosMaxY \
-width $LargeurDuTrait \
-fill $Couleur \
-tags [list "Box" "$Boite"]
}
Wup " .......................................... et Rscope crea les boites."
DefinirLaCouleurAuLancement $K
$K $Bind "RepereBox" <1> "$K delete current"
$K $Bind "SelectionNucleique" <1> "$K delete current"
$K $Bind "Box" <1> "FetcheBox $K %x %y"
$K $Bind "Box" <Shift-1> "FetcheBox $K %x %y"
$K $Bind "Box" <Control-1> "Informe \[Box \[BoiteDuCourant $K %x %y\] nom \]"
$K $Bind "Box" <Shift-2> "OrganismesOrthologues $K %x %y"
$K $Bind "Box" <Control-2> "SautParalogue $K %x %y"
$K $Bind "Box" <3> "PiqueBox $K %x %y Fixe"
$Bind $K <Shift-3> "ShowNucRosace $K %x %y Point"
$Bind $K <Shift-B3-Motion> "ShowNucRosace $K %x %y Motion"
$Bind $K <2> "$K scan mark %x %y"
$Bind $K <B2-Motion> "$K scan dragto %x %y"
if {$PourGif } { return $LesOrdresPourGif }
if { ! $PourGif } {
set KanvaCourant $K
set RosaceCourante $K
lappend ParametresDuBoard(RosacesEnCours) $K
lappend LesKanvasOuverts $K
JeMeSignale "FinPatience"
if {0 && [PourWscope] } {
return $w
} else {
return $K
}
}
}
proc Scene {K Action Quoi} {
global SceneMemo
if { ! [info exists SceneMemo($K,font)]} { set SceneMemo($K,font) {{Courier 8} {Courier 10} {Courier 12}} }
if { ! [info exists SceneMemo($K,fill)]} { set SceneMemo($K,fill) {black white} }
if {$Action=="toggle"} {
set Top [lindex [set SceneMemo($K,$Quoi)] 0]
set SceneMemo($K,$Quoi) [lreplace [set SceneMemo($K,$Quoi)] 0 0]
lappend SceneMemo($K,$Quoi) $Top
set Nouveau [lindex [set SceneMemo($K,$Quoi)] 0]
$K itemconfigure TEXTE -$Quoi $Nouveau
}
return $Nouveau
}
Index by: file name |
procedure name |
procedure call |
annotation
File generated 2022-04-05 at 12:55.