2494 lines
107 KiB
Go
2494 lines
107 KiB
Go
|
|
package gui
|
|
|
|
// viewAnalysisGui_Couple.go implements pages to view a couple genetic analysis
|
|
|
|
import "fyne.io/fyne/v2"
|
|
import "fyne.io/fyne/v2/container"
|
|
import "fyne.io/fyne/v2/layout"
|
|
import "fyne.io/fyne/v2/theme"
|
|
import "fyne.io/fyne/v2/widget"
|
|
|
|
import "seekia/resources/geneticReferences/monogenicDiseases"
|
|
import "seekia/resources/geneticReferences/polygenicDiseases"
|
|
import "seekia/resources/geneticReferences/traits"
|
|
|
|
import "seekia/internal/appMemory"
|
|
import "seekia/internal/genetics/myGenomes"
|
|
import "seekia/internal/genetics/myPeople"
|
|
import "seekia/internal/genetics/readGeneticAnalysis"
|
|
import "seekia/internal/helpers"
|
|
|
|
import "strings"
|
|
import "errors"
|
|
|
|
|
|
func setViewCoupleGeneticAnalysisPage(window fyne.Window, personAIdentifier string, personBIdentifier string, personAAnalysisMapList []map[string]string, personBAnalysisMapList []map[string]string, coupleAnalysisMapList []map[string]string, numberOfPersonAGenomesAnalyzed int, numberOfPersonBGenomesAnalyzed int, previousPage func()){
|
|
|
|
appMemory.SetMemoryEntry("CurrentViewedPage", "ViewCoupleGeneticAnalysisPage")
|
|
|
|
currentPage := func(){setViewCoupleGeneticAnalysisPage(window, personAIdentifier, personBIdentifier, personAAnalysisMapList, personBAnalysisMapList, coupleAnalysisMapList, numberOfPersonAGenomesAnalyzed, numberOfPersonBGenomesAnalyzed, previousPage)}
|
|
|
|
title := getPageTitleCentered("Viewing Genetic Analysis")
|
|
|
|
backButton := getBackButtonCentered(previousPage)
|
|
|
|
warningLabel := getBoldLabelCentered("WARNING: Results are not accurate!")
|
|
|
|
personAFound, personAName, _, _, err := myPeople.GetPersonInfo(personAIdentifier)
|
|
if (err != nil) {
|
|
setErrorEncounteredPage(window, err, previousPage)
|
|
return
|
|
}
|
|
if (personAFound == false){
|
|
setErrorEncounteredPage(window, errors.New("Couple person A not found."), previousPage)
|
|
return
|
|
}
|
|
|
|
personBFound, personBName, _, _, err := myPeople.GetPersonInfo(personBIdentifier)
|
|
if (err != nil) {
|
|
setErrorEncounteredPage(window, err, previousPage)
|
|
return
|
|
}
|
|
if (personBFound == false){
|
|
setErrorEncounteredPage(window, errors.New("Couple person B not found."), previousPage)
|
|
return
|
|
}
|
|
|
|
coupleNameLabel := widget.NewLabel("Couple Name:")
|
|
coupleNameText := getBoldLabel(personAName + " + " + personBName)
|
|
coupleNameRow := container.NewHBox(layout.NewSpacer(), coupleNameLabel, coupleNameText, layout.NewSpacer())
|
|
|
|
numberOfAnalyzedGenomesLabel := getLabelCentered("Number of Analyzed Genomes:")
|
|
|
|
personANameLabel := widget.NewLabel(personAName + ":")
|
|
personANumberOfGenomesAnalyzedString := helpers.ConvertIntToString(numberOfPersonAGenomesAnalyzed)
|
|
personANumberOfGenomesAnalyzedLabel := getBoldLabel(personANumberOfGenomesAnalyzedString)
|
|
personANumberOfAnalyzedGenomesRow := container.NewHBox(layout.NewSpacer(), personANameLabel, personANumberOfGenomesAnalyzedLabel, layout.NewSpacer())
|
|
|
|
personBNameLabel := widget.NewLabel(personBName + ":")
|
|
personBNumberOfGenomesAnalyzedString := helpers.ConvertIntToString(numberOfPersonBGenomesAnalyzed)
|
|
personBNumberOfGenomesAnalyzedLabel := getBoldLabel(personBNumberOfGenomesAnalyzedString)
|
|
personBNumberOfAnalyzedGenomesRow := container.NewHBox(layout.NewSpacer(), personBNameLabel, personBNumberOfGenomesAnalyzedLabel, layout.NewSpacer())
|
|
|
|
generalButton := widget.NewButton("General", func(){
|
|
//TODO: Offspring inbred rating (kinship of parents), ancestry
|
|
showUnderConstructionDialog(window)
|
|
})
|
|
monogenicDiseasesButton := widget.NewButton("Monogenic Diseases", func(){
|
|
setViewCoupleGeneticAnalysisMonogenicDiseasesPage(window, personAName, personBName, personAAnalysisMapList, personBAnalysisMapList, coupleAnalysisMapList, currentPage)
|
|
})
|
|
polygenicDiseasesButton := widget.NewButton("Polygenic Diseases", func(){
|
|
setViewCoupleGeneticAnalysisPolygenicDiseasesPage(window, personAName, personBName, personAAnalysisMapList, personBAnalysisMapList, coupleAnalysisMapList, currentPage)
|
|
})
|
|
traitsButton := widget.NewButton("Traits", func(){
|
|
setViewCoupleGeneticAnalysisTraitsPage(window, personAName, personBName, personAAnalysisMapList, personBAnalysisMapList, coupleAnalysisMapList, currentPage)
|
|
})
|
|
|
|
categoryButtonsGrid := getContainerCentered(container.NewGridWithColumns(1, generalButton, monogenicDiseasesButton, polygenicDiseasesButton, traitsButton))
|
|
|
|
page := container.NewVBox(title, backButton, widget.NewSeparator(), warningLabel, widget.NewSeparator(), coupleNameRow, widget.NewSeparator(), numberOfAnalyzedGenomesLabel, personANumberOfAnalyzedGenomesRow, personBNumberOfAnalyzedGenomesRow, widget.NewSeparator(), categoryButtonsGrid)
|
|
|
|
setPageContent(page, window)
|
|
}
|
|
|
|
|
|
func setViewCoupleGeneticAnalysisMonogenicDiseasesPage(window fyne.Window, personAName string, personBName string, personAAnalysisMapList []map[string]string, personBAnalysisMapList []map[string]string, coupleAnalysisMapList []map[string]string, previousPage func()){
|
|
|
|
currentPage := func(){setViewCoupleGeneticAnalysisMonogenicDiseasesPage(window, personAName, personBName, personAAnalysisMapList, personBAnalysisMapList, coupleAnalysisMapList, previousPage)}
|
|
|
|
title := getPageTitleCentered("Viewing Genetic Analysis - Monogenic Diseases")
|
|
|
|
backButton := getBackButtonCentered(previousPage)
|
|
|
|
description := getLabelCentered("Below is an analysis of the monogenic disease probabilities for the couple's offspring.")
|
|
|
|
//TODO: Sort so highest risk diseases are at the top. Everything else should be in normal order
|
|
|
|
getMonogenicDiseasesGrid := func()(*fyne.Container, error){
|
|
|
|
pair1PersonAGenomeIdentifier, pair1PersonBGenomeIdentifier, secondGenomePairExists, _, _, _, _, _, _, _, _, err := readGeneticAnalysis.GetMetadataFromCoupleGeneticAnalysis(coupleAnalysisMapList)
|
|
if (err != nil){ return nil, err }
|
|
|
|
emptyLabelA := widget.NewLabel("")
|
|
diseaseNameLabel := getItalicLabelCentered("Disease Name")
|
|
|
|
offspringProbabilityOfLabel := getItalicLabelCentered("Offspring Probability Of")
|
|
havingDiseaseLabel := getItalicLabelCentered("Having Disease")
|
|
|
|
emptyLabelB := widget.NewLabel("")
|
|
conflictExistsLabel := getItalicLabelCentered("Conflict Exists?")
|
|
|
|
emptyLabelC := widget.NewLabel("")
|
|
emptyLabelD := widget.NewLabel("")
|
|
|
|
diseaseNameColumn := container.NewVBox(emptyLabelA, diseaseNameLabel, widget.NewSeparator())
|
|
offspringProbabilityOfHavingDiseaseColumn := container.NewVBox(offspringProbabilityOfLabel, havingDiseaseLabel, widget.NewSeparator())
|
|
conflictExistsColumn := container.NewVBox(emptyLabelB, conflictExistsLabel, widget.NewSeparator())
|
|
viewButtonsColumn := container.NewVBox(emptyLabelC, emptyLabelD, widget.NewSeparator())
|
|
|
|
monogenicDiseaseNamesList, err := monogenicDiseases.GetMonogenicDiseaseNamesList()
|
|
if (err != nil){ return nil, err }
|
|
|
|
for _, diseaseName := range monogenicDiseaseNamesList{
|
|
|
|
pair1GenomeIdentifier := pair1PersonAGenomeIdentifier + "+" + pair1PersonBGenomeIdentifier
|
|
|
|
genomeProbabilitiesKnown, _, genomePairOffspringProbabilityOfHavingDisease, _, _, conflictExists, err := readGeneticAnalysis.GetOffspringMonogenicDiseaseInfoFromGeneticAnalysis(coupleAnalysisMapList, diseaseName, pair1GenomeIdentifier, secondGenomePairExists)
|
|
if (err != nil) { return nil, err }
|
|
|
|
getOffspringProbabilityOfHavingDiseaseText := func()string{
|
|
if (genomeProbabilitiesKnown == false){
|
|
result := translate("Unknown")
|
|
return result
|
|
}
|
|
|
|
return genomePairOffspringProbabilityOfHavingDisease
|
|
}
|
|
|
|
offspringProbabilityOfHavingDiseaseText := getOffspringProbabilityOfHavingDiseaseText()
|
|
|
|
diseaseNameText := getBoldLabelCentered(diseaseName)
|
|
diseaseNameColumn.Add(diseaseNameText)
|
|
|
|
offspringProbabilityOfHavingDiseaseLabel := getBoldLabelCentered(offspringProbabilityOfHavingDiseaseText)
|
|
offspringProbabilityOfHavingDiseaseColumn.Add(offspringProbabilityOfHavingDiseaseLabel)
|
|
|
|
conflictExistsString := helpers.ConvertBoolToYesOrNoString(conflictExists)
|
|
conflictExistsLabel := getBoldLabelCentered(conflictExistsString)
|
|
conflictExistsColumn.Add(conflictExistsLabel)
|
|
|
|
viewDetailsButton := getWidgetCentered(widget.NewButtonWithIcon("", theme.VisibilityIcon(), func(){
|
|
setViewCoupleGeneticAnalysisMonogenicDiseaseDetailsPage(window, personAName, personBName, personAAnalysisMapList, personBAnalysisMapList, coupleAnalysisMapList, diseaseName, currentPage)
|
|
}))
|
|
viewButtonsColumn.Add(viewDetailsButton)
|
|
|
|
diseaseNameColumn.Add(widget.NewSeparator())
|
|
offspringProbabilityOfHavingDiseaseColumn.Add(widget.NewSeparator())
|
|
conflictExistsColumn.Add(widget.NewSeparator())
|
|
viewButtonsColumn.Add(widget.NewSeparator())
|
|
}
|
|
|
|
offspringProbabilityOfHavingDiseaseHelpButton := widget.NewButtonWithIcon("", theme.QuestionIcon(), func(){
|
|
setOffspringProbabilityOfHavingMonogenicDiseaseExplainerPage(window, currentPage)
|
|
})
|
|
offspringProbabilityOfHavingDiseaseColumn.Add(offspringProbabilityOfHavingDiseaseHelpButton)
|
|
|
|
diseasesGrid := container.NewHBox(layout.NewSpacer(), diseaseNameColumn, offspringProbabilityOfHavingDiseaseColumn)
|
|
|
|
if (secondGenomePairExists == true){
|
|
|
|
conflictExistsHelpButton := widget.NewButtonWithIcon("", theme.QuestionIcon(), func(){
|
|
setCoupleGeneticAnalysisConflictExistsExplainerPage(window, currentPage)
|
|
})
|
|
conflictExistsColumn.Add(conflictExistsHelpButton)
|
|
|
|
diseasesGrid.Add(conflictExistsColumn)
|
|
}
|
|
|
|
diseasesGrid.Add(viewButtonsColumn)
|
|
diseasesGrid.Add(layout.NewSpacer())
|
|
|
|
return diseasesGrid, nil
|
|
}
|
|
|
|
monogenicDiseasesContainer, err := getMonogenicDiseasesGrid()
|
|
if (err != nil){
|
|
setErrorEncounteredPage(window, err, previousPage)
|
|
return
|
|
}
|
|
|
|
page := container.NewVBox(title, backButton, widget.NewSeparator(), description, widget.NewSeparator(), monogenicDiseasesContainer)
|
|
|
|
setPageContent(page, window)
|
|
}
|
|
|
|
|
|
func setViewCoupleGeneticAnalysisMonogenicDiseaseDetailsPage(window fyne.Window, personAName string, personBName string, personAAnalysisMapList []map[string]string, personBAnalysisMapList []map[string]string, coupleAnalysisMapList []map[string]string, diseaseName string, previousPage func()){
|
|
|
|
currentPage := func(){setViewCoupleGeneticAnalysisMonogenicDiseaseDetailsPage(window, personAName, personBName, personAAnalysisMapList, personBAnalysisMapList, coupleAnalysisMapList, diseaseName, previousPage)}
|
|
|
|
title := getPageTitleCentered("Viewing Couple Analysis - " + diseaseName)
|
|
|
|
backButton := getBackButtonCentered(previousPage)
|
|
|
|
pair1PersonAGenomeIdentifier, pair1PersonBGenomeIdentifier, secondGenomePairExists, pair2PersonAGenomeIdentifier, pair2PersonBGenomeIdentifier, _, _, _, _, _, _, err := readGeneticAnalysis.GetMetadataFromCoupleGeneticAnalysis(coupleAnalysisMapList)
|
|
if (err != nil){
|
|
setErrorEncounteredPage(window, err, previousPage)
|
|
return
|
|
}
|
|
|
|
getDescriptionSection := func()*fyne.Container{
|
|
|
|
if (secondGenomePairExists == false){
|
|
description := getLabelCentered("Below are the disease probabilities for the couple's offspring.")
|
|
|
|
return description
|
|
}
|
|
|
|
description1 := getLabelCentered("Below are the disease probabilities for the couple's offspring.")
|
|
description2 := getLabelCentered("Each genome pair combines different genomes from each person.")
|
|
|
|
descriptionsSection := container.NewVBox(description1, description2)
|
|
|
|
return descriptionsSection
|
|
}
|
|
|
|
descriptionSection := getDescriptionSection()
|
|
|
|
diseaseNameLabel := widget.NewLabel("Disease:")
|
|
diseaseNameText := getBoldLabel(diseaseName)
|
|
diseaseNameInfoButton := widget.NewButtonWithIcon("", theme.InfoIcon(), func(){
|
|
setViewMonogenicDiseaseDetailsPage(window, diseaseName, currentPage)
|
|
})
|
|
diseaseNameRow := container.NewHBox(layout.NewSpacer(), diseaseNameLabel, diseaseNameText, diseaseNameInfoButton, layout.NewSpacer())
|
|
|
|
emptyLabel1 := widget.NewLabel("")
|
|
emptyLabel2 := widget.NewLabel("")
|
|
|
|
emptyLabel3 := widget.NewLabel("")
|
|
emptyLabel4 := widget.NewLabel("")
|
|
|
|
offspringProbabilityOfLabel1 := getItalicLabelCentered("Offspring Probability Of")
|
|
havingDiseaseLabel := getItalicLabelCentered("Having Disease")
|
|
|
|
offspringProbabilityOfLabel2 := getItalicLabelCentered("Offspring Probability Of")
|
|
havingVariantLabel := getItalicLabelCentered("Having Variant")
|
|
|
|
emptyLabel5 := widget.NewLabel("")
|
|
emptyLabel6 := widget.NewLabel("")
|
|
|
|
viewGenomePairButtonsColumn := container.NewVBox(emptyLabel1, emptyLabel2, widget.NewSeparator())
|
|
pairNameColumn := container.NewVBox(emptyLabel3, emptyLabel4, widget.NewSeparator())
|
|
offspringProbabilityOfHavingDiseaseColumn := container.NewVBox(offspringProbabilityOfLabel1, havingDiseaseLabel, widget.NewSeparator())
|
|
offspringProbabilityOfHavingVariantColumn := container.NewVBox(offspringProbabilityOfLabel2, havingVariantLabel, widget.NewSeparator())
|
|
viewOffspringVariantButtonsColumn := container.NewVBox(emptyLabel5, emptyLabel6, widget.NewSeparator())
|
|
|
|
addGenomePairRow := func(genomePairName string, personAGenomeIdentifier string, personBGenomeIdentifier string)error{
|
|
|
|
genomePairIdentifier := personAGenomeIdentifier + "+" + personBGenomeIdentifier
|
|
|
|
genomeProbabilitiesKnown, _, genomePairOffspringProbabilityOfHavingDisease, _, genomePairOffspringProbabilityOfHavingAVariant, _, err := readGeneticAnalysis.GetOffspringMonogenicDiseaseInfoFromGeneticAnalysis(coupleAnalysisMapList, diseaseName, genomePairIdentifier, secondGenomePairExists)
|
|
if (err != nil) { return err }
|
|
|
|
getOffspringProbabilityOfHavingDiseaseText := func()string{
|
|
if (genomeProbabilitiesKnown == false){
|
|
result := translate("Unknown")
|
|
return result
|
|
}
|
|
|
|
return genomePairOffspringProbabilityOfHavingDisease
|
|
}
|
|
|
|
offspringProbabilityOfHavingDiseaseText := getOffspringProbabilityOfHavingDiseaseText()
|
|
|
|
getOffspringProbabilityOfHavingAVariantText := func()string{
|
|
|
|
if (genomeProbabilitiesKnown == false){
|
|
result := translate("Unknown")
|
|
return result
|
|
}
|
|
return genomePairOffspringProbabilityOfHavingAVariant
|
|
}
|
|
|
|
offspringProbabilityOfHavingAVariantText := getOffspringProbabilityOfHavingAVariantText()
|
|
|
|
genomePairNameLabel := getBoldLabelCentered(genomePairName)
|
|
|
|
offspringProbabilityOfHavingDiseaseLabel := getBoldLabelCentered(offspringProbabilityOfHavingDiseaseText)
|
|
|
|
offspringProbabilityOfHavingAVariantLabel := getBoldLabelCentered(offspringProbabilityOfHavingAVariantText)
|
|
|
|
viewGenomePairButton := widget.NewButtonWithIcon("", theme.InfoIcon(), func(){
|
|
setViewCoupleGeneticAnalysisMonogenicDiseaseGenomePairDetailsPage(window, personAName, personBName, personAAnalysisMapList, personBAnalysisMapList, coupleAnalysisMapList, diseaseName, genomePairIdentifier, genomePairName, currentPage)
|
|
})
|
|
|
|
viewOffspringVariantsButton := widget.NewButtonWithIcon("", theme.VisibilityIcon(), func(){
|
|
setViewCoupleMonogenicDiseaseVariantsPage(window, personAName, personBName, personAAnalysisMapList, personBAnalysisMapList, coupleAnalysisMapList, diseaseName, genomePairIdentifier, genomePairName, currentPage)
|
|
})
|
|
|
|
viewGenomePairButtonsColumn.Add(viewGenomePairButton)
|
|
pairNameColumn.Add(genomePairNameLabel)
|
|
offspringProbabilityOfHavingDiseaseColumn.Add(offspringProbabilityOfHavingDiseaseLabel)
|
|
offspringProbabilityOfHavingVariantColumn.Add(offspringProbabilityOfHavingAVariantLabel)
|
|
viewOffspringVariantButtonsColumn.Add(viewOffspringVariantsButton)
|
|
|
|
viewGenomePairButtonsColumn.Add(widget.NewSeparator())
|
|
pairNameColumn.Add(widget.NewSeparator())
|
|
offspringProbabilityOfHavingDiseaseColumn.Add(widget.NewSeparator())
|
|
offspringProbabilityOfHavingVariantColumn.Add(widget.NewSeparator())
|
|
viewOffspringVariantButtonsColumn.Add(widget.NewSeparator())
|
|
|
|
return nil
|
|
}
|
|
|
|
err = addGenomePairRow("Pair 1", pair1PersonAGenomeIdentifier, pair1PersonBGenomeIdentifier)
|
|
if (err != nil) {
|
|
setErrorEncounteredPage(window, err, previousPage)
|
|
return
|
|
}
|
|
|
|
if (secondGenomePairExists == true){
|
|
err := addGenomePairRow("Pair 2", pair2PersonAGenomeIdentifier, pair2PersonBGenomeIdentifier)
|
|
if (err != nil) {
|
|
setErrorEncounteredPage(window, err, previousPage)
|
|
return
|
|
}
|
|
}
|
|
|
|
offspringProbabilityOfHavingDiseaseHelpButton := widget.NewButtonWithIcon("", theme.QuestionIcon(), func(){
|
|
setOffspringProbabilityOfHavingMonogenicDiseaseExplainerPage(window, currentPage)
|
|
})
|
|
|
|
offspringProbabilityOfHavingVariantHelpButton := widget.NewButtonWithIcon("", theme.QuestionIcon(), func(){
|
|
setOffspringProbabilityOfHavingVariantExplainerPage(window, currentPage)
|
|
})
|
|
|
|
offspringProbabilityOfHavingDiseaseColumn.Add(offspringProbabilityOfHavingDiseaseHelpButton)
|
|
offspringProbabilityOfHavingVariantColumn.Add(offspringProbabilityOfHavingVariantHelpButton)
|
|
|
|
genomesContainer := container.NewHBox(layout.NewSpacer(), viewGenomePairButtonsColumn, pairNameColumn, offspringProbabilityOfHavingDiseaseColumn, offspringProbabilityOfHavingVariantColumn, viewOffspringVariantButtonsColumn, layout.NewSpacer())
|
|
|
|
page := container.NewVBox(title, backButton, widget.NewSeparator(), descriptionSection, widget.NewSeparator(), diseaseNameRow, widget.NewSeparator(), genomesContainer)
|
|
|
|
setPageContent(page, window)
|
|
}
|
|
|
|
|
|
func setViewCoupleGeneticAnalysisMonogenicDiseaseGenomePairDetailsPage(window fyne.Window, personAName string, personBName string, personAAnalysisMapList []map[string]string, personBAnalysisMapList []map[string]string, coupleAnalysisMapList []map[string]string, diseaseName string, genomePairIdentifier string, genomePairName string, previousPage func()){
|
|
|
|
currentPage := func(){setViewCoupleGeneticAnalysisMonogenicDiseaseGenomePairDetailsPage(window, personAName, personBName, personAAnalysisMapList, personBAnalysisMapList, coupleAnalysisMapList, diseaseName, genomePairIdentifier, genomePairName, previousPage)}
|
|
|
|
title := getPageTitleCentered("Viewing Couple Genome Pair Info")
|
|
|
|
backButton := getBackButtonCentered(previousPage)
|
|
|
|
description := getLabelCentered("Below is the disease information for both genomes in the genome pair.")
|
|
|
|
diseaseNameLabel := widget.NewLabel("Disease:")
|
|
diseaseNameText := getBoldLabel(diseaseName)
|
|
diseaseNameInfoButton := widget.NewButtonWithIcon("", theme.InfoIcon(), func(){
|
|
setViewMonogenicDiseaseDetailsPage(window, diseaseName, currentPage)
|
|
})
|
|
diseaseNameRow := container.NewHBox(layout.NewSpacer(), diseaseNameLabel, diseaseNameText, diseaseNameInfoButton, layout.NewSpacer())
|
|
|
|
genomePairLabel := widget.NewLabel("Genome Pair:")
|
|
genomePairNameLabel := getBoldLabel(genomePairName)
|
|
genomePairHelpButton := widget.NewButtonWithIcon("", theme.QuestionIcon(), func(){
|
|
setCoupleGenomePairExplainerPage(window, currentPage)
|
|
})
|
|
genomePairRow := container.NewHBox(layout.NewSpacer(), genomePairLabel, genomePairNameLabel, genomePairHelpButton, layout.NewSpacer())
|
|
|
|
emptyLabelA := widget.NewLabel("")
|
|
personNameLabel := getItalicLabelCentered("Person Name")
|
|
|
|
emptyLabelB := widget.NewLabel("")
|
|
genomeNameLabel := getItalicLabelCentered("Genome Name")
|
|
|
|
probabilityOfLabel := getItalicLabelCentered("Probability Of")
|
|
passingAVariantLabel := getItalicLabelCentered("Passing A Variant")
|
|
|
|
numberOfLabel := getItalicLabelCentered("Number Of")
|
|
variantsTestedLabel := getItalicLabelCentered("Variants Tested")
|
|
|
|
emptyLabelC := widget.NewLabel("")
|
|
emptyLabelD := widget.NewLabel("")
|
|
|
|
personNameColumn := container.NewVBox(emptyLabelA, personNameLabel, widget.NewSeparator())
|
|
genomeNameColumn := container.NewVBox(emptyLabelB, genomeNameLabel, widget.NewSeparator())
|
|
probabilityOfPassingAVariantColumn := container.NewVBox(probabilityOfLabel, passingAVariantLabel, widget.NewSeparator())
|
|
numberOfVariantsTestedColumn := container.NewVBox(numberOfLabel, variantsTestedLabel, widget.NewSeparator())
|
|
viewGenomeButtonsColumn := container.NewVBox(emptyLabelC, emptyLabelD, widget.NewSeparator())
|
|
|
|
addGenomeRow := func(isPersonA bool, personName string, inputGenomeIdentifier string)error{
|
|
|
|
personAnalysisGenomeIdentifier, personHasMultipleGenomes, genomeIsCombined, combinedType, err := readGeneticAnalysis.GetMatchingPersonAnalysisGenomeIdentifierFromCoupleAnalysis(isPersonA, personAAnalysisMapList, personBAnalysisMapList, coupleAnalysisMapList, inputGenomeIdentifier)
|
|
if (err != nil) { return err }
|
|
|
|
personNameTrimmed, _, err := helpers.TrimAndFlattenString(personName, 10)
|
|
if (err != nil) { return err }
|
|
|
|
personNameLabel := getBoldLabelCentered(personNameTrimmed)
|
|
|
|
getPersonAnalysisMapList := func()[]map[string]string{
|
|
if (isPersonA == true){
|
|
return personAAnalysisMapList
|
|
}
|
|
return personBAnalysisMapList
|
|
}
|
|
|
|
personAnalysisMapList := getPersonAnalysisMapList()
|
|
|
|
getGenomeName := func()(string, error){
|
|
|
|
if (genomeIsCombined == false){
|
|
|
|
genomeFound, _, _, _, _, _, companyName, _, _, err := myGenomes.GetMyRawGenomeMetadata(personAnalysisGenomeIdentifier)
|
|
if (err != nil) { return "", err }
|
|
if (genomeFound == false){
|
|
return "", errors.New("MyGenomeInfo for genome from analysisMapList not found.")
|
|
}
|
|
|
|
return companyName, nil
|
|
}
|
|
|
|
return combinedType, nil
|
|
}
|
|
|
|
genomeName, err := getGenomeName()
|
|
if (err != nil) { return err }
|
|
|
|
genomeNameLabel := getBoldLabelCentered(genomeName)
|
|
|
|
probabilitiesKnown, _, _, _, probabilityOfPassingAVariantFormatted, personNumberOfVariantsTested, _, err := readGeneticAnalysis.GetPersonMonogenicDiseaseInfoFromGeneticAnalysis(personAnalysisMapList, diseaseName, personAnalysisGenomeIdentifier, personHasMultipleGenomes)
|
|
if (err != nil) { return err }
|
|
|
|
getProbabilityOfPassingAVariantText := func()string{
|
|
|
|
if (probabilitiesKnown == false){
|
|
|
|
result := translate("Unknown")
|
|
return result
|
|
}
|
|
|
|
return probabilityOfPassingAVariantFormatted
|
|
}
|
|
genomeProbabilityOfPassingAVariantText := getProbabilityOfPassingAVariantText()
|
|
|
|
genomeProbabilityOfPassingAVariantLabel := getBoldLabelCentered(genomeProbabilityOfPassingAVariantText)
|
|
|
|
personNumberOfVariantsTestedString := helpers.ConvertIntToString(personNumberOfVariantsTested)
|
|
genomeNumberOfVariantsTestedLabel := getBoldLabelCentered(personNumberOfVariantsTestedString)
|
|
|
|
viewGenomeButton := widget.NewButtonWithIcon("", theme.VisibilityIcon(), func(){
|
|
setViewPersonGenomeMonogenicDiseaseVariantsPage(window, personAnalysisMapList, personAnalysisGenomeIdentifier, genomeName, diseaseName, currentPage)
|
|
})
|
|
|
|
personNameColumn.Add(personNameLabel)
|
|
genomeNameColumn.Add(genomeNameLabel)
|
|
probabilityOfPassingAVariantColumn.Add(genomeProbabilityOfPassingAVariantLabel)
|
|
numberOfVariantsTestedColumn.Add(genomeNumberOfVariantsTestedLabel)
|
|
viewGenomeButtonsColumn.Add(viewGenomeButton)
|
|
|
|
personNameColumn.Add(widget.NewSeparator())
|
|
genomeNameColumn.Add(widget.NewSeparator())
|
|
probabilityOfPassingAVariantColumn.Add(widget.NewSeparator())
|
|
numberOfVariantsTestedColumn.Add(widget.NewSeparator())
|
|
viewGenomeButtonsColumn.Add(widget.NewSeparator())
|
|
|
|
return nil
|
|
}
|
|
|
|
personAGenomeIdentifier, personBGenomeIdentifier, found := strings.Cut(genomePairIdentifier, "+")
|
|
if (found == false){
|
|
setErrorEncounteredPage(window, errors.New("setViewCoupleGeneticAnalysisMonogenicDiseaseGenomePairDetailsPage called with invalid genomePairIdentifier"), previousPage)
|
|
return
|
|
}
|
|
|
|
err := addGenomeRow(true, personAName, personAGenomeIdentifier)
|
|
if (err != nil){
|
|
setErrorEncounteredPage(window, err, previousPage)
|
|
return
|
|
}
|
|
err = addGenomeRow(false, personBName, personBGenomeIdentifier)
|
|
if (err != nil){
|
|
setErrorEncounteredPage(window, err, previousPage)
|
|
return
|
|
}
|
|
|
|
probabilityOfPassingAVariantHelpButton := widget.NewButtonWithIcon("", theme.QuestionIcon(), func(){
|
|
setPersonProbabilityOfPassingVariantExplainerPage(window, currentPage)
|
|
})
|
|
numberOfVariantsTestedHelpButton := widget.NewButtonWithIcon("", theme.QuestionIcon(), func(){
|
|
setNumberOfTestedVariantsExplainerPage(window, currentPage)
|
|
})
|
|
|
|
probabilityOfPassingAVariantColumn.Add(probabilityOfPassingAVariantHelpButton)
|
|
numberOfVariantsTestedColumn.Add(numberOfVariantsTestedHelpButton)
|
|
|
|
genomesGrid := container.NewHBox(layout.NewSpacer(), personNameColumn, genomeNameColumn, probabilityOfPassingAVariantColumn, numberOfVariantsTestedColumn, viewGenomeButtonsColumn, layout.NewSpacer())
|
|
|
|
page := container.NewVBox(title, backButton, widget.NewSeparator(), description, diseaseNameRow, genomePairRow, widget.NewSeparator(), genomesGrid)
|
|
|
|
setPageContent(page, window)
|
|
}
|
|
|
|
|
|
// This function provides a page to view the offspring disease variant probabilities for a particular genome pair from a couple genetic analysis
|
|
func setViewCoupleMonogenicDiseaseVariantsPage(window fyne.Window, personAName string, personBName string, personAAnalysisMapList []map[string]string, personBAnalysisMapList []map[string]string, coupleAnalysisMapList []map[string]string, diseaseName string, genomePairIdentifier string, genomePairName string, previousPage func()){
|
|
|
|
setLoadingScreen(window, "Loading Disease Variants", "Loading disease variants...")
|
|
|
|
currentPage := func(){setViewCoupleMonogenicDiseaseVariantsPage(window, personAName, personBName, personAAnalysisMapList, personBAnalysisMapList, coupleAnalysisMapList, diseaseName, genomePairIdentifier, genomePairName, previousPage)}
|
|
|
|
title := getPageTitleCentered("View Offspring Disease Variants - " + diseaseName)
|
|
|
|
backButton := getBackButtonCentered(previousPage)
|
|
|
|
description1 := widget.NewLabel("Below are the disease variant probabilities for offspring from this genome pair.")
|
|
variantsHelpButton := widget.NewButtonWithIcon("", theme.QuestionIcon(), func(){
|
|
setMonogenicDiseaseVariantsExplainerPage(window, currentPage)
|
|
})
|
|
description1Row := container.NewHBox(layout.NewSpacer(), description1, variantsHelpButton, layout.NewSpacer())
|
|
|
|
genomePairLabel := widget.NewLabel("Genome Pair:")
|
|
genomePairNameLabel := getBoldLabel(genomePairName)
|
|
viewGenomePairInfoButton := widget.NewButtonWithIcon("", theme.InfoIcon(), func(){
|
|
setViewCoupleGeneticAnalysisMonogenicDiseaseGenomePairDetailsPage(window, personAName, personBName, personAAnalysisMapList, personBAnalysisMapList, coupleAnalysisMapList, diseaseName, genomePairIdentifier, genomePairName, currentPage)
|
|
})
|
|
|
|
genomePairRow := container.NewHBox(layout.NewSpacer(), genomePairLabel, genomePairNameLabel, viewGenomePairInfoButton, layout.NewSpacer())
|
|
|
|
getNumberOfVariantsTested := func()(int, error){
|
|
|
|
personAGenomeIdentifier, personBGenomeIdentifier, found := strings.Cut(genomePairIdentifier, "+")
|
|
if (found == false){
|
|
return 0, errors.New("setViewCoupleMonogenicDiseaseVariantsPage called with invalid genomePairIdentifier: " + genomePairIdentifier)
|
|
}
|
|
|
|
personAAnalysisGenomeIdentifier, personAHasMultipleGenomes, _, _, err := readGeneticAnalysis.GetMatchingPersonAnalysisGenomeIdentifierFromCoupleAnalysis(true, personAAnalysisMapList, personBAnalysisMapList, coupleAnalysisMapList, personAGenomeIdentifier)
|
|
if (err != nil) { return 0, err }
|
|
|
|
_, _, _, _, _, personANumberOfVariantsTested, _, err := readGeneticAnalysis.GetPersonMonogenicDiseaseInfoFromGeneticAnalysis(personAAnalysisMapList, diseaseName, personAAnalysisGenomeIdentifier, personAHasMultipleGenomes)
|
|
if (err != nil) { return 0, err }
|
|
|
|
personBAnalysisGenomeIdentifier, personBHasMultipleGenomes, _, _, err := readGeneticAnalysis.GetMatchingPersonAnalysisGenomeIdentifierFromCoupleAnalysis(false, personAAnalysisMapList, personBAnalysisMapList, coupleAnalysisMapList, personBGenomeIdentifier)
|
|
if (err != nil) { return 0, err }
|
|
|
|
_, _, _, _, _, personBNumberOfVariantsTested, _, err := readGeneticAnalysis.GetPersonMonogenicDiseaseInfoFromGeneticAnalysis(personBAnalysisMapList, diseaseName, personBAnalysisGenomeIdentifier, personBHasMultipleGenomes)
|
|
if (err != nil) { return 0, err }
|
|
|
|
numberOfVariantsTested := personANumberOfVariantsTested + personBNumberOfVariantsTested
|
|
|
|
return numberOfVariantsTested, nil
|
|
}
|
|
|
|
numberOfVariantsTested, err := getNumberOfVariantsTested()
|
|
if (err != nil){
|
|
setErrorEncounteredPage(window, err, previousPage)
|
|
return
|
|
}
|
|
|
|
diseaseVariantsMap, err := monogenicDiseases.GetMonogenicDiseaseVariantsMap(diseaseName)
|
|
if (err != nil){
|
|
setErrorEncounteredPage(window, err, previousPage)
|
|
return
|
|
}
|
|
|
|
totalNumberOfVariants := len(diseaseVariantsMap) * 2
|
|
totalNumberOfVariantsString := helpers.ConvertIntToString(totalNumberOfVariants)
|
|
|
|
numberOfVariantsTestedString := helpers.ConvertIntToString(numberOfVariantsTested)
|
|
|
|
variantsTestedLabel := widget.NewLabel("Variants Tested:")
|
|
variantsTestedText := getBoldLabel(numberOfVariantsTestedString + "/" + totalNumberOfVariantsString)
|
|
variantsTestedHelpButton := widget.NewButtonWithIcon("", theme.QuestionIcon(), func(){
|
|
setNumberOfTestedVariantsExplainerPage(window, currentPage)
|
|
})
|
|
|
|
variantsTestedRow := container.NewHBox(layout.NewSpacer(), variantsTestedLabel, variantsTestedText, variantsTestedHelpButton, layout.NewSpacer())
|
|
|
|
//TODO: Add navigation with pages
|
|
|
|
getVariantsGrid := func()(*fyne.Container, error){
|
|
|
|
emptyLabelA := widget.NewLabel("")
|
|
variantNameLabel := getItalicLabelCentered("Variant Name")
|
|
|
|
probabilityOfLabelA := getItalicLabelCentered("Probability Of")
|
|
zeroMutationsLabel := getItalicLabelCentered("0 Mutations")
|
|
|
|
probabilityOfLabelB := getItalicLabelCentered("Probability Of")
|
|
oneMutationLabel := getItalicLabelCentered("1 Mutation")
|
|
|
|
probabilityOfLabelC := getItalicLabelCentered("Probability Of")
|
|
twoMutationsLabel := getItalicLabelCentered("2 Mutations")
|
|
|
|
emptyLabelB := widget.NewLabel("")
|
|
emptyLabelC := widget.NewLabel("")
|
|
|
|
variantNameColumn := container.NewVBox(emptyLabelA, variantNameLabel, widget.NewSeparator())
|
|
probabilityOf0MutationsColumn := container.NewVBox(probabilityOfLabelA, zeroMutationsLabel, widget.NewSeparator())
|
|
probabilityOf1MutationColumn := container.NewVBox(probabilityOfLabelB, oneMutationLabel, widget.NewSeparator())
|
|
probabilityOf2MutationsColumn := container.NewVBox(probabilityOfLabelC, twoMutationsLabel, widget.NewSeparator())
|
|
variantInfoButtonsColumn := container.NewVBox(emptyLabelB, emptyLabelC, widget.NewSeparator())
|
|
|
|
addVariantRow := func(variantIdentifier string)error{
|
|
|
|
variantObject, exists := diseaseVariantsMap[variantIdentifier]
|
|
if (exists == false){
|
|
return errors.New("Cannot add variant row: Variant missing from diseaseVariantsMap")
|
|
}
|
|
|
|
variantName := variantObject.VariantNames[0]
|
|
|
|
offspringProbabilitiesKnown, probabilityOf0MutationsLowerBound, probabilityOf0MutationsUpperBound, probabilityOf0MutationsFormatted, probabilityOf1MutationLowerBound, probabilityOf1MutationUpperBound, probabilityOf1MutationFormatted, probabilityOf2MutationsLowerBound, probabilityOf2MutationsUpperBound, probabilityOf2MutationsFormatted, err := readGeneticAnalysis.GetOffspringMonogenicDiseaseVariantInfoFromGeneticAnalysis(coupleAnalysisMapList, diseaseName, variantIdentifier, genomePairIdentifier)
|
|
if (err != nil) { return err }
|
|
|
|
getProbabilityOf0MutationsText := func()string{
|
|
if (offspringProbabilitiesKnown == false){
|
|
|
|
result := translate("Unknown")
|
|
return result
|
|
}
|
|
if (probabilityOf0MutationsLowerBound == 0 && probabilityOf0MutationsUpperBound == 100){
|
|
result := translate("Unknown")
|
|
return result
|
|
}
|
|
|
|
return probabilityOf0MutationsFormatted
|
|
}
|
|
|
|
probabilityOf0MutationsText := getProbabilityOf0MutationsText()
|
|
|
|
getProbabilityOf1MutationText := func()string{
|
|
if (offspringProbabilitiesKnown == false){
|
|
|
|
result := translate("Unknown")
|
|
return result
|
|
}
|
|
if (probabilityOf1MutationLowerBound == 0 && probabilityOf1MutationUpperBound == 100){
|
|
result := translate("Unknown")
|
|
return result
|
|
}
|
|
|
|
return probabilityOf1MutationFormatted
|
|
}
|
|
|
|
probabilityOf1MutationText := getProbabilityOf1MutationText()
|
|
|
|
getProbabilityOf2MutationsText := func()string{
|
|
if (offspringProbabilitiesKnown == false){
|
|
|
|
result := translate("Unknown")
|
|
return result
|
|
}
|
|
if (probabilityOf2MutationsLowerBound == 0 && probabilityOf2MutationsUpperBound == 100){
|
|
result := translate("Unknown")
|
|
return result
|
|
}
|
|
|
|
return probabilityOf2MutationsFormatted
|
|
}
|
|
|
|
probabilityOf2MutationsText := getProbabilityOf2MutationsText()
|
|
|
|
variantNameLabel := getBoldLabelCentered(variantName)
|
|
|
|
probabilityOf0MutationsLabel := getBoldLabelCentered(probabilityOf0MutationsText)
|
|
probabilityOf1MutationLabel := getBoldLabelCentered(probabilityOf1MutationText)
|
|
probabilityOf2MutationsLabel := getBoldLabelCentered(probabilityOf2MutationsText)
|
|
|
|
viewVariantDetailsButton := widget.NewButtonWithIcon("", theme.VisibilityIcon(), func(){
|
|
setViewCoupleGeneticAnalysisMonogenicDiseaseVariantDetailsPage(window, personAName, personBName, personAAnalysisMapList, personBAnalysisMapList, coupleAnalysisMapList, diseaseName, variantIdentifier, currentPage)
|
|
})
|
|
|
|
variantNameColumn.Add(variantNameLabel)
|
|
probabilityOf0MutationsColumn.Add(probabilityOf0MutationsLabel)
|
|
probabilityOf1MutationColumn.Add(probabilityOf1MutationLabel)
|
|
probabilityOf2MutationsColumn.Add(probabilityOf2MutationsLabel)
|
|
variantInfoButtonsColumn.Add(viewVariantDetailsButton)
|
|
|
|
variantNameColumn.Add(widget.NewSeparator())
|
|
probabilityOf0MutationsColumn.Add(widget.NewSeparator())
|
|
probabilityOf1MutationColumn.Add(widget.NewSeparator())
|
|
probabilityOf2MutationsColumn.Add(widget.NewSeparator())
|
|
variantInfoButtonsColumn.Add(widget.NewSeparator())
|
|
|
|
return nil
|
|
}
|
|
|
|
variantsWithNonZeroRiskList := make([]string, 0)
|
|
variantsWithZeroRiskFullyKnownList := make([]string, 0)
|
|
variantsWithZeroRiskPartiallyKnownList := make([]string, 0)
|
|
variantsWithUnknownRiskList := make([]string, 0)
|
|
|
|
for variantIdentifier, _ := range diseaseVariantsMap{
|
|
|
|
probabilitesKnown, probabilityOf0MutationsLowerBound, probabilityOf0MutationsUpperBound, _, probabilityOf1MutationLowerBound, probabilityOf1MutationUpperBound, _, probabilityOf2MutationsLowerBound, probabilityOf2MutationsUpperBound, _, err := readGeneticAnalysis.GetOffspringMonogenicDiseaseVariantInfoFromGeneticAnalysis(coupleAnalysisMapList, diseaseName, variantIdentifier, genomePairIdentifier)
|
|
if (err != nil) { return nil, err }
|
|
|
|
if (probabilitesKnown == false){
|
|
variantsWithUnknownRiskList = append(variantsWithUnknownRiskList, variantIdentifier)
|
|
continue
|
|
}
|
|
|
|
if (probabilityOf1MutationLowerBound != 0 || probabilityOf2MutationsLowerBound != 0){
|
|
variantsWithNonZeroRiskList = append(variantsWithNonZeroRiskList, variantIdentifier)
|
|
continue
|
|
}
|
|
|
|
// Risk is either 0 or partially unknown
|
|
if (probabilityOf0MutationsLowerBound == 100 && probabilityOf0MutationsUpperBound == 100 && probabilityOf1MutationLowerBound == 0 && probabilityOf1MutationUpperBound == 0 && probabilityOf2MutationsLowerBound == 0 && probabilityOf2MutationsUpperBound == 0){
|
|
variantsWithZeroRiskFullyKnownList = append(variantsWithZeroRiskFullyKnownList, variantIdentifier)
|
|
continue
|
|
}
|
|
|
|
variantsWithZeroRiskPartiallyKnownList = append(variantsWithZeroRiskPartiallyKnownList, variantIdentifier)
|
|
}
|
|
|
|
// We sort each list so the variants show up in the same order each time
|
|
|
|
helpers.SortStringListToUnicodeOrder(variantsWithNonZeroRiskList)
|
|
helpers.SortStringListToUnicodeOrder(variantsWithZeroRiskFullyKnownList)
|
|
helpers.SortStringListToUnicodeOrder(variantsWithZeroRiskPartiallyKnownList)
|
|
helpers.SortStringListToUnicodeOrder(variantsWithUnknownRiskList)
|
|
|
|
for _, variantIdentifier := range variantsWithNonZeroRiskList{
|
|
|
|
err = addVariantRow(variantIdentifier)
|
|
if (err != nil) { return nil, err }
|
|
}
|
|
for _, variantIdentifier := range variantsWithZeroRiskFullyKnownList{
|
|
|
|
err = addVariantRow(variantIdentifier)
|
|
if (err != nil) { return nil, err }
|
|
}
|
|
for _, variantIdentifier := range variantsWithZeroRiskPartiallyKnownList{
|
|
|
|
err = addVariantRow(variantIdentifier)
|
|
if (err != nil) { return nil, err }
|
|
}
|
|
for _, variantIdentifier := range variantsWithUnknownRiskList{
|
|
|
|
err = addVariantRow(variantIdentifier)
|
|
if (err != nil) { return nil, err }
|
|
}
|
|
|
|
variantsGrid := container.NewHBox(layout.NewSpacer(), variantNameColumn, probabilityOf0MutationsColumn, probabilityOf1MutationColumn, probabilityOf2MutationsColumn, variantInfoButtonsColumn, layout.NewSpacer())
|
|
|
|
return variantsGrid, nil
|
|
}
|
|
|
|
variantsGrid, err := getVariantsGrid()
|
|
if (err != nil){
|
|
setErrorEncounteredPage(window, err, previousPage)
|
|
return
|
|
}
|
|
|
|
page := container.NewVBox(title, backButton, widget.NewSeparator(), description1Row, widget.NewSeparator(), genomePairRow, widget.NewSeparator(), variantsTestedRow, widget.NewSeparator(), variantsGrid)
|
|
|
|
setPageContent(page, window)
|
|
}
|
|
|
|
|
|
|
|
// This function provides a page to view the details of a specific variant from a genetic analysis
|
|
// It will show the variant details for all of the couple's genome pairs
|
|
func setViewCoupleGeneticAnalysisMonogenicDiseaseVariantDetailsPage(window fyne.Window, personAName string, personBName string, personAAnalysisMapList []map[string]string, personBAnalysisMapList []map[string]string, coupleAnalysisMapList []map[string]string, diseaseName string, variantIdentifier string, previousPage func()){
|
|
|
|
currentPage := func(){setViewCoupleGeneticAnalysisMonogenicDiseaseVariantDetailsPage(window, personAName, personBName, personAAnalysisMapList, personBAnalysisMapList, coupleAnalysisMapList, diseaseName, variantIdentifier, previousPage)}
|
|
|
|
title := getPageTitleCentered("Disease Variant Details - " + diseaseName)
|
|
|
|
backButton := getBackButtonCentered(previousPage)
|
|
|
|
variantObject, err := monogenicDiseases.GetMonogenicDiseaseVariantObject(diseaseName, variantIdentifier)
|
|
if (err != nil) {
|
|
setErrorEncounteredPage(window, err, previousPage)
|
|
return
|
|
}
|
|
|
|
variantName := variantObject.VariantNames[0]
|
|
|
|
description := getLabelCentered("Below is the disease variant analysis for the couple.")
|
|
|
|
variantNameLabel := widget.NewLabel("Variant Name:")
|
|
variantNameText := getBoldLabel(variantName)
|
|
variantInfoButton := widget.NewButtonWithIcon("", theme.InfoIcon(), func(){
|
|
setViewMonogenicDiseaseVariantDetailsPage(window, diseaseName, variantIdentifier, currentPage)
|
|
})
|
|
variantNameRow := container.NewHBox(layout.NewSpacer(), variantNameLabel, variantNameText, variantInfoButton, layout.NewSpacer())
|
|
|
|
getGenomePairsHaveVariantGrid := func()(*fyne.Container, error){
|
|
|
|
emptyLabelA := widget.NewLabel("")
|
|
emptyLabelB := widget.NewLabel("")
|
|
|
|
emptyLabelC := widget.NewLabel("")
|
|
genomePairLabel := getItalicLabelCentered("Genome Pair")
|
|
|
|
probabilityOfLabelA := getItalicLabelCentered("Probability Of")
|
|
zeroMutationsLabel := getItalicLabelCentered("0 Mutations")
|
|
|
|
probabilityOfLabelB := getItalicLabelCentered("Probability Of")
|
|
oneMutationLabel := getItalicLabelCentered("1 Mutation")
|
|
|
|
probabilityOfLabelC := getItalicLabelCentered("Probability Of")
|
|
twoMutationsLabel := getItalicLabelCentered("2 Mutations")
|
|
|
|
viewGenomePairInfoButtonsColumn := container.NewVBox(emptyLabelA, emptyLabelB, widget.NewSeparator())
|
|
genomePairNameColumn := container.NewVBox(emptyLabelC, genomePairLabel, widget.NewSeparator())
|
|
probabilityOf0MutationsColumn := container.NewVBox(probabilityOfLabelA, zeroMutationsLabel, widget.NewSeparator())
|
|
probabilityOf1MutationColumn := container.NewVBox(probabilityOfLabelB, oneMutationLabel, widget.NewSeparator())
|
|
probablityOf2MutationsColumn := container.NewVBox(probabilityOfLabelC, twoMutationsLabel, widget.NewSeparator())
|
|
|
|
addGenomePairRow := func(genomePairName string, genomePairIdentifier string)error{
|
|
|
|
probabilitiesKnown, probabilityOf0MutationsLowerBound, probabilityOf0MutationsUpperBound, probabilityOf0MutationsFormatted, probabilityOf1MutationLowerBound, probabilityOf1MutationUpperBound, probabilityOf1MutationFormatted, probabilityOf2MutationsLowerBound, probabilityOf2MutationsUpperBound, probabilityOf2MutationsFormatted, err := readGeneticAnalysis.GetOffspringMonogenicDiseaseVariantInfoFromGeneticAnalysis(coupleAnalysisMapList, diseaseName, variantIdentifier, genomePairIdentifier)
|
|
if (err != nil) { return err }
|
|
|
|
getProbabilityOf0MutationsText := func()string{
|
|
if (probabilitiesKnown == false){
|
|
|
|
result := translate("Unknown")
|
|
return result
|
|
}
|
|
if (probabilityOf0MutationsLowerBound == 0 && probabilityOf0MutationsUpperBound == 100){
|
|
result := translate("Unknown")
|
|
return result
|
|
}
|
|
|
|
return probabilityOf0MutationsFormatted
|
|
}
|
|
|
|
probabilityOf0MutationsText := getProbabilityOf0MutationsText()
|
|
|
|
getProbabilityOf1MutationText := func()string{
|
|
if (probabilitiesKnown == false){
|
|
|
|
result := translate("Unknown")
|
|
return result
|
|
}
|
|
if (probabilityOf1MutationLowerBound == 0 && probabilityOf1MutationUpperBound == 100){
|
|
result := translate("Unknown")
|
|
return result
|
|
}
|
|
|
|
return probabilityOf1MutationFormatted
|
|
}
|
|
|
|
probabilityOf1MutationText := getProbabilityOf1MutationText()
|
|
|
|
getProbabilityOf2MutationsText := func()string{
|
|
if (probabilitiesKnown == false){
|
|
|
|
result := translate("Unknown")
|
|
return result
|
|
}
|
|
if (probabilityOf2MutationsLowerBound == 0 && probabilityOf2MutationsUpperBound == 100){
|
|
result := translate("Unknown")
|
|
return result
|
|
}
|
|
|
|
return probabilityOf2MutationsFormatted
|
|
}
|
|
|
|
probabilityOf2MutationsText := getProbabilityOf2MutationsText()
|
|
|
|
viewGenomePairInfoButton := widget.NewButtonWithIcon("", theme.InfoIcon(), func(){
|
|
setViewCoupleGeneticAnalysisMonogenicDiseaseGenomePairDetailsPage(window, personAName, personBName, personAAnalysisMapList, personBAnalysisMapList, coupleAnalysisMapList, diseaseName, genomePairIdentifier, genomePairName, currentPage)
|
|
})
|
|
|
|
genomePairNameLabel := getBoldLabelCentered(genomePairName)
|
|
|
|
probabilityOf0MutationsLabel := getBoldLabelCentered(probabilityOf0MutationsText)
|
|
probabilityOf1MutationLabel := getBoldLabelCentered(probabilityOf1MutationText)
|
|
probabilityOf2MutationsLabel := getBoldLabelCentered(probabilityOf2MutationsText)
|
|
|
|
viewGenomePairInfoButtonsColumn.Add(viewGenomePairInfoButton)
|
|
genomePairNameColumn.Add(genomePairNameLabel)
|
|
probabilityOf0MutationsColumn.Add(probabilityOf0MutationsLabel)
|
|
probabilityOf1MutationColumn.Add(probabilityOf1MutationLabel)
|
|
probablityOf2MutationsColumn.Add(probabilityOf2MutationsLabel)
|
|
|
|
viewGenomePairInfoButtonsColumn.Add(widget.NewSeparator())
|
|
genomePairNameColumn.Add(widget.NewSeparator())
|
|
probabilityOf0MutationsColumn.Add(widget.NewSeparator())
|
|
probabilityOf1MutationColumn.Add(widget.NewSeparator())
|
|
probablityOf2MutationsColumn.Add(widget.NewSeparator())
|
|
|
|
return nil
|
|
}
|
|
|
|
pair1PersonAGenomeIdentifier, pair1PersonBGenomeIdentifier, secondGenomePairExists, pair2PersonAGenomeIdentifier, pair2PersonBGenomeIdentifier, _, _, _, _, _, _, err := readGeneticAnalysis.GetMetadataFromCoupleGeneticAnalysis(coupleAnalysisMapList)
|
|
if (err != nil){ return nil, err }
|
|
|
|
genomePair1Identifier := pair1PersonAGenomeIdentifier + "+" + pair1PersonBGenomeIdentifier
|
|
|
|
err = addGenomePairRow("Pair 1", genomePair1Identifier)
|
|
if (err != nil) { return nil, err }
|
|
|
|
if (secondGenomePairExists == true){
|
|
|
|
genomePair2Identifier := pair2PersonAGenomeIdentifier + "+" + pair2PersonBGenomeIdentifier
|
|
|
|
err := addGenomePairRow("Pair 2", genomePair2Identifier)
|
|
if (err != nil) { return nil, err }
|
|
}
|
|
|
|
genomesContainer := container.NewHBox(layout.NewSpacer(), viewGenomePairInfoButtonsColumn, genomePairNameColumn, probabilityOf0MutationsColumn, probabilityOf1MutationColumn, probablityOf2MutationsColumn, layout.NewSpacer())
|
|
|
|
return genomesContainer, nil
|
|
}
|
|
|
|
genomePairsHaveVariantGrid, err := getGenomePairsHaveVariantGrid()
|
|
if (err != nil){
|
|
setErrorEncounteredPage(window, err, previousPage)
|
|
return
|
|
}
|
|
|
|
page := container.NewVBox(title, backButton, widget.NewSeparator(), description, widget.NewSeparator(), variantNameRow, widget.NewSeparator(), genomePairsHaveVariantGrid)
|
|
|
|
setPageContent(page, window)
|
|
}
|
|
|
|
|
|
func setViewCoupleGeneticAnalysisPolygenicDiseasesPage(window fyne.Window, personAName string, personBName string, personAAnalysisMapList []map[string]string, personBAnalysisMapList []map[string]string, coupleAnalysisMapList []map[string]string, previousPage func()){
|
|
|
|
currentPage := func(){setViewCoupleGeneticAnalysisPolygenicDiseasesPage(window, personAName, personBName, personAAnalysisMapList, personBAnalysisMapList, coupleAnalysisMapList, previousPage)}
|
|
|
|
title := getPageTitleCentered("Viewing Genetic Analysis - Polygenic Diseases")
|
|
|
|
backButton := getBackButtonCentered(previousPage)
|
|
|
|
description := getLabelCentered("Below is an analysis of the polygenic disease risk probabilities for the couple's offspring.")
|
|
|
|
getDiseasesGrid := func()(*fyne.Container, error){
|
|
|
|
pair1PersonAGenomeIdentifier, pair1PersonBGenomeIdentifier, secondGenomePairExists, _, _, _, _, _, _, _, _, err := readGeneticAnalysis.GetMetadataFromCoupleGeneticAnalysis(coupleAnalysisMapList)
|
|
if (err != nil){ return nil, err }
|
|
|
|
diseaseNameLabel := getItalicLabelCentered("Disease Name")
|
|
|
|
offspringRiskScoreLabel := getItalicLabelCentered("Offspring Risk Score")
|
|
|
|
conflictExistsLabel := getItalicLabelCentered("Conflict Exists?")
|
|
|
|
emptyLabel := widget.NewLabel("")
|
|
|
|
diseaseNameColumn := container.NewVBox(diseaseNameLabel, widget.NewSeparator())
|
|
offspringRiskScoreColumn := container.NewVBox(offspringRiskScoreLabel, widget.NewSeparator())
|
|
conflictExistsColumn := container.NewVBox(conflictExistsLabel, widget.NewSeparator())
|
|
viewButtonsColumn := container.NewVBox(emptyLabel, widget.NewSeparator())
|
|
|
|
diseaseNamesList, err := polygenicDiseases.GetPolygenicDiseaseNamesList()
|
|
if (err != nil) { return nil, err }
|
|
|
|
for _, diseaseName := range diseaseNamesList{
|
|
|
|
mainGenomePairIdentifier := pair1PersonAGenomeIdentifier + "+" + pair1PersonBGenomeIdentifier
|
|
|
|
offspringRiskScoreKnown, _, offspringRiskScoreFormatted, _, conflictExists, err := readGeneticAnalysis.GetOffspringPolygenicDiseaseInfoFromGeneticAnalysis(coupleAnalysisMapList, diseaseName, mainGenomePairIdentifier, secondGenomePairExists)
|
|
if (err != nil) { return nil, err }
|
|
|
|
getRiskScoreLabelText := func()string{
|
|
|
|
if (offspringRiskScoreKnown == false){
|
|
result := translate("Unknown")
|
|
|
|
return result
|
|
}
|
|
|
|
return offspringRiskScoreFormatted
|
|
}
|
|
|
|
offspringRiskScoreLabelText := getRiskScoreLabelText()
|
|
|
|
diseaseNameText := getBoldLabelCentered(diseaseName)
|
|
diseaseNameColumn.Add(diseaseNameText)
|
|
|
|
offspringRiskScoreText := getBoldLabelCentered(offspringRiskScoreLabelText)
|
|
offspringRiskScoreColumn.Add(offspringRiskScoreText)
|
|
|
|
conflictExistsString := helpers.ConvertBoolToYesOrNoString(conflictExists)
|
|
conflictExistsLabel := getBoldLabelCentered(conflictExistsString)
|
|
conflictExistsColumn.Add(conflictExistsLabel)
|
|
|
|
viewDetailsButton := getWidgetCentered(widget.NewButtonWithIcon("", theme.VisibilityIcon(), func(){
|
|
setViewCoupleGeneticAnalysisPolygenicDiseaseDetailsPage(window, personAName, personBName, personAAnalysisMapList, personBAnalysisMapList, coupleAnalysisMapList, diseaseName, currentPage)
|
|
}))
|
|
viewButtonsColumn.Add(viewDetailsButton)
|
|
|
|
diseaseNameColumn.Add(widget.NewSeparator())
|
|
offspringRiskScoreColumn.Add(widget.NewSeparator())
|
|
conflictExistsColumn.Add(widget.NewSeparator())
|
|
viewButtonsColumn.Add(widget.NewSeparator())
|
|
}
|
|
|
|
offspringRiskScoreHelpButton := widget.NewButtonWithIcon("", theme.QuestionIcon(), func(){
|
|
setOffspringPolygenicDiseaseRiskScoreExplainerPage(window, currentPage)
|
|
})
|
|
offspringRiskScoreColumn.Add(offspringRiskScoreHelpButton)
|
|
|
|
diseasesGrid := container.NewHBox(layout.NewSpacer(), diseaseNameColumn, offspringRiskScoreColumn)
|
|
|
|
if (secondGenomePairExists == true){
|
|
|
|
conflictExistsHelpButton := widget.NewButtonWithIcon("", theme.QuestionIcon(), func(){
|
|
setCoupleGeneticAnalysisConflictExistsExplainerPage(window, currentPage)
|
|
})
|
|
conflictExistsColumn.Add(conflictExistsHelpButton)
|
|
|
|
diseasesGrid.Add(conflictExistsColumn)
|
|
}
|
|
|
|
diseasesGrid.Add(viewButtonsColumn)
|
|
diseasesGrid.Add(layout.NewSpacer())
|
|
|
|
return diseasesGrid, nil
|
|
}
|
|
|
|
diseasesGrid, err := getDiseasesGrid()
|
|
if (err != nil){
|
|
setErrorEncounteredPage(window, err, previousPage)
|
|
return
|
|
}
|
|
|
|
page := container.NewVBox(title, backButton, widget.NewSeparator(), description, widget.NewSeparator(), diseasesGrid)
|
|
|
|
setPageContent(page, window)
|
|
}
|
|
|
|
func setViewCoupleGeneticAnalysisPolygenicDiseaseDetailsPage(window fyne.Window, personAName string, personBName string, personAAnalysisMapList []map[string]string, personBAnalysisMapList []map[string]string, coupleAnalysisMapList []map[string]string, diseaseName string, previousPage func()){
|
|
|
|
currentPage := func(){setViewCoupleGeneticAnalysisPolygenicDiseaseDetailsPage(window, personAName, personBName, personAAnalysisMapList, personBAnalysisMapList, coupleAnalysisMapList, diseaseName, previousPage)}
|
|
|
|
title := getPageTitleCentered("Viewing Couple Analysis - " + diseaseName)
|
|
|
|
backButton := getBackButtonCentered(previousPage)
|
|
|
|
pair1PersonAGenomeIdentifier, pair1PersonBGenomeIdentifier, secondGenomePairExists, pair2PersonAGenomeIdentifier, pair2PersonBGenomeIdentifier, _, _, _, _, _, _, err := readGeneticAnalysis.GetMetadataFromCoupleGeneticAnalysis(coupleAnalysisMapList)
|
|
if (err != nil){
|
|
setErrorEncounteredPage(window, err, previousPage)
|
|
return
|
|
}
|
|
|
|
getDescriptionSection := func()*fyne.Container{
|
|
|
|
if (secondGenomePairExists == false){
|
|
description := getLabelCentered("Below is the disease analysis for the couple's offspring.")
|
|
|
|
return description
|
|
}
|
|
|
|
description1 := getLabelCentered("Below is the disease analysis for the couple's offspring.")
|
|
description2 := getLabelCentered("Each genome pair combines different genomes from each person.")
|
|
|
|
descriptionsSection := container.NewVBox(description1, description2)
|
|
|
|
return descriptionsSection
|
|
}
|
|
|
|
descriptionSection := getDescriptionSection()
|
|
|
|
diseaseNameLabel := widget.NewLabel("Disease:")
|
|
diseaseNameText := getBoldLabel(diseaseName)
|
|
diseaseNameInfoButton := widget.NewButtonWithIcon("", theme.InfoIcon(), func(){
|
|
setViewPolygenicDiseaseDetailsPage(window, diseaseName, currentPage)
|
|
})
|
|
diseaseNameRow := container.NewHBox(layout.NewSpacer(), diseaseNameLabel, diseaseNameText, diseaseNameInfoButton, layout.NewSpacer())
|
|
|
|
emptyLabelA := widget.NewLabel("")
|
|
emptyLabelB := widget.NewLabel("")
|
|
|
|
offspringRiskScoreLabel := getItalicLabelCentered("Offspring Risk Score")
|
|
|
|
emptyLabelC := widget.NewLabel("")
|
|
emptyLabelD := widget.NewLabel("")
|
|
|
|
viewGenomePairButtonsColumn := container.NewVBox(emptyLabelA, widget.NewSeparator())
|
|
pairNameColumn := container.NewVBox(emptyLabelB, widget.NewSeparator())
|
|
offspringRiskScoreColumn := container.NewVBox(offspringRiskScoreLabel, widget.NewSeparator())
|
|
viewLifetimeRiskButtonsColumn := container.NewVBox(emptyLabelC, widget.NewSeparator())
|
|
viewOffspringLociButtonsColumn := container.NewVBox(emptyLabelD, widget.NewSeparator())
|
|
|
|
addGenomePairRow := func(genomePairName string, personAGenomeIdentifier string, personBGenomeIdentifier string)error{
|
|
|
|
genomePairIdentifier := personAGenomeIdentifier + "+" + personBGenomeIdentifier
|
|
|
|
offspringRiskScoreKnown, _, offspringRiskScoreFormatted, _, _, err := readGeneticAnalysis.GetOffspringPolygenicDiseaseInfoFromGeneticAnalysis(coupleAnalysisMapList, diseaseName, genomePairIdentifier, secondGenomePairExists)
|
|
if (err != nil) { return err }
|
|
|
|
getRiskScoreLabelText := func()string{
|
|
|
|
if (offspringRiskScoreKnown == false){
|
|
result := translate("Unknown")
|
|
|
|
return result
|
|
}
|
|
|
|
return offspringRiskScoreFormatted
|
|
}
|
|
|
|
riskScoreLabelText := getRiskScoreLabelText()
|
|
|
|
genomePairNameLabel := getBoldLabelCentered(genomePairName)
|
|
|
|
offspringRiskScoreLabel := getBoldLabelCentered(riskScoreLabelText)
|
|
|
|
viewGenomePairButton := widget.NewButtonWithIcon("", theme.InfoIcon(), func(){
|
|
setViewCoupleGeneticAnalysisPolygenicDiseaseGenomePairDetailsPage(window, personAName, personBName, personAAnalysisMapList, personBAnalysisMapList, coupleAnalysisMapList, diseaseName, genomePairIdentifier, genomePairName, currentPage)
|
|
})
|
|
|
|
viewOffspringLifetimeRiskButton := widget.NewButtonWithIcon("", theme.HistoryIcon(), func(){
|
|
|
|
diseaseObject, err := polygenicDiseases.GetPolygenicDiseaseObject(diseaseName)
|
|
if (err != nil){
|
|
setErrorEncounteredPage(window, err, currentPage)
|
|
return
|
|
}
|
|
|
|
getPageMaleOrFemale := func()string{
|
|
|
|
//TODO: Get user sex from myLocalProfiles
|
|
|
|
diseaseEffectedSex := diseaseObject.EffectedSex
|
|
if (diseaseEffectedSex == "Both"){
|
|
return "Male"
|
|
}
|
|
|
|
return diseaseEffectedSex
|
|
}
|
|
|
|
pageMaleOrFemale := getPageMaleOrFemale()
|
|
|
|
setViewPersonPolygenicDiseaseLifetimeProbabilitiesPage(window, diseaseName, genomePairName, pageMaleOrFemale, currentPage)
|
|
})
|
|
|
|
viewOffspringLociButton := widget.NewButtonWithIcon("", theme.VisibilityIcon(), func(){
|
|
setViewCouplePolygenicDiseaseLociPage(window, personAName, personBName, personAAnalysisMapList, personBAnalysisMapList, coupleAnalysisMapList, diseaseName, genomePairIdentifier, genomePairName, currentPage)
|
|
})
|
|
|
|
viewGenomePairButtonsColumn.Add(viewGenomePairButton)
|
|
pairNameColumn.Add(genomePairNameLabel)
|
|
offspringRiskScoreColumn.Add(offspringRiskScoreLabel)
|
|
viewLifetimeRiskButtonsColumn.Add(viewOffspringLifetimeRiskButton)
|
|
viewOffspringLociButtonsColumn.Add(viewOffspringLociButton)
|
|
|
|
viewGenomePairButtonsColumn.Add(widget.NewSeparator())
|
|
pairNameColumn.Add(widget.NewSeparator())
|
|
offspringRiskScoreColumn.Add(widget.NewSeparator())
|
|
viewOffspringLociButtonsColumn.Add(widget.NewSeparator())
|
|
|
|
return nil
|
|
}
|
|
|
|
err = addGenomePairRow("Pair 1", pair1PersonAGenomeIdentifier, pair1PersonBGenomeIdentifier)
|
|
if (err != nil) {
|
|
setErrorEncounteredPage(window, err, previousPage)
|
|
return
|
|
}
|
|
|
|
if (secondGenomePairExists == true){
|
|
err := addGenomePairRow("Pair 2", pair2PersonAGenomeIdentifier, pair2PersonBGenomeIdentifier)
|
|
if (err != nil) {
|
|
setErrorEncounteredPage(window, err, previousPage)
|
|
return
|
|
}
|
|
}
|
|
|
|
offspringRiskScoreHelpButton := widget.NewButtonWithIcon("", theme.QuestionIcon(), func(){
|
|
setOffspringPolygenicDiseaseRiskScoreExplainerPage(window, currentPage)
|
|
})
|
|
|
|
offspringRiskScoreColumn.Add(offspringRiskScoreHelpButton)
|
|
|
|
genomesContainer := container.NewHBox(layout.NewSpacer(), viewGenomePairButtonsColumn, pairNameColumn, offspringRiskScoreColumn, viewOffspringLociButtonsColumn, layout.NewSpacer())
|
|
|
|
page := container.NewVBox(title, backButton, widget.NewSeparator(), descriptionSection, widget.NewSeparator(), diseaseNameRow, widget.NewSeparator(), genomesContainer)
|
|
|
|
setPageContent(page, window)
|
|
}
|
|
|
|
|
|
func setViewCoupleGeneticAnalysisPolygenicDiseaseGenomePairDetailsPage(window fyne.Window, personAName string, personBName string, personAAnalysisMapList []map[string]string, personBAnalysisMapList []map[string]string, coupleAnalysisMapList []map[string]string, diseaseName string, genomePairIdentifier string, genomePairName string, previousPage func()){
|
|
|
|
currentPage := func(){setViewCoupleGeneticAnalysisPolygenicDiseaseGenomePairDetailsPage(window, personAName, personBName, personAAnalysisMapList, personBAnalysisMapList, coupleAnalysisMapList, diseaseName, genomePairIdentifier, genomePairName, previousPage)}
|
|
|
|
title := getPageTitleCentered("Viewing Couple Genome Pair Info")
|
|
|
|
backButton := getBackButtonCentered(previousPage)
|
|
|
|
description := getLabelCentered("Below is the disease information for both genomes in the genome pair.")
|
|
|
|
diseaseNameLabel := widget.NewLabel("Disease:")
|
|
diseaseNameText := getBoldLabel(diseaseName)
|
|
diseaseNameInfoButton := widget.NewButtonWithIcon("", theme.InfoIcon(), func(){
|
|
setViewPolygenicDiseaseDetailsPage(window, diseaseName, currentPage)
|
|
})
|
|
diseaseNameRow := container.NewHBox(layout.NewSpacer(), diseaseNameLabel, diseaseNameText, diseaseNameInfoButton, layout.NewSpacer())
|
|
|
|
genomePairLabel := widget.NewLabel("Genome Pair:")
|
|
genomePairNameLabel := getBoldLabel(genomePairName)
|
|
genomePairHelpButton := widget.NewButtonWithIcon("", theme.QuestionIcon(), func(){
|
|
setCoupleGenomePairExplainerPage(window, currentPage)
|
|
})
|
|
genomePairRow := container.NewHBox(layout.NewSpacer(), genomePairLabel, genomePairNameLabel, genomePairHelpButton, layout.NewSpacer())
|
|
|
|
emptyLabelA := widget.NewLabel("")
|
|
personNameLabel := getItalicLabelCentered("Person Name")
|
|
|
|
emptyLabelB := widget.NewLabel("")
|
|
genomeNameLabel := getItalicLabelCentered("Genome Name")
|
|
|
|
emptyLabelC := widget.NewLabel("")
|
|
riskScoreLabel := getItalicLabelCentered("Risk Score")
|
|
|
|
numberOfLabel := getItalicLabelCentered("Number Of")
|
|
lociTestedLabel := getItalicLabelCentered("Loci Tested")
|
|
|
|
emptyLabelD := widget.NewLabel("")
|
|
emptyLabelE := widget.NewLabel("")
|
|
|
|
personNameColumn := container.NewVBox(emptyLabelA, personNameLabel, widget.NewSeparator())
|
|
genomeNameColumn := container.NewVBox(emptyLabelB, genomeNameLabel, widget.NewSeparator())
|
|
riskScoreColumn := container.NewVBox(emptyLabelC, riskScoreLabel, widget.NewSeparator())
|
|
numberOfLociTestedColumn := container.NewVBox(numberOfLabel, lociTestedLabel, widget.NewSeparator())
|
|
viewGenomeButtonsColumn := container.NewVBox(emptyLabelD, emptyLabelE, widget.NewSeparator())
|
|
|
|
addGenomeRow := func(isPersonA bool, personName string, inputGenomeIdentifier string)error{
|
|
|
|
personAnalysisGenomeIdentifier, personHasMultipleGenomes, genomeIsCombined, combinedType, err := readGeneticAnalysis.GetMatchingPersonAnalysisGenomeIdentifierFromCoupleAnalysis(isPersonA, personAAnalysisMapList, personBAnalysisMapList, coupleAnalysisMapList, inputGenomeIdentifier)
|
|
if (err != nil) { return err }
|
|
|
|
personNameTrimmed, _, err := helpers.TrimAndFlattenString(personName, 10)
|
|
if (err != nil) { return err }
|
|
|
|
personNameLabel := getBoldLabelCentered(personNameTrimmed)
|
|
|
|
getPersonAnalysisMapList := func()[]map[string]string{
|
|
if (isPersonA == true){
|
|
return personAAnalysisMapList
|
|
}
|
|
return personBAnalysisMapList
|
|
}
|
|
|
|
personAnalysisMapList := getPersonAnalysisMapList()
|
|
|
|
getGenomeName := func()(string, error){
|
|
|
|
if (genomeIsCombined == false){
|
|
|
|
genomeFound, _, _, _, _, _, companyName, _, _, err := myGenomes.GetMyRawGenomeMetadata(personAnalysisGenomeIdentifier)
|
|
if (err != nil) { return "", err }
|
|
if (genomeFound == false){
|
|
return "", errors.New("MyGenomeInfo for genome from analysisMapList not found.")
|
|
}
|
|
|
|
return companyName, nil
|
|
}
|
|
|
|
return combinedType, nil
|
|
}
|
|
|
|
genomeName, err := getGenomeName()
|
|
if (err != nil) { return err }
|
|
|
|
genomeNameLabel := getBoldLabelCentered(genomeName)
|
|
|
|
personRiskScoreKnown, _, personRiskScoreFormatted, numberOfLociTested, _, err := readGeneticAnalysis.GetPersonPolygenicDiseaseInfoFromGeneticAnalysis(personAnalysisMapList, diseaseName, personAnalysisGenomeIdentifier, personHasMultipleGenomes)
|
|
if (err != nil) { return err }
|
|
|
|
getPersonRiskScoreLabelText := func()string{
|
|
if (personRiskScoreKnown == false){
|
|
result := translate("Unknown")
|
|
return result
|
|
}
|
|
return personRiskScoreFormatted
|
|
}
|
|
|
|
personRiskScoreLabelText := getPersonRiskScoreLabelText()
|
|
|
|
genomeRiskScoreLabel := getBoldLabelCentered(personRiskScoreLabelText)
|
|
|
|
numberOfLociTestedString := helpers.ConvertIntToString(numberOfLociTested)
|
|
numberOfLociTestedText := getBoldLabelCentered(numberOfLociTestedString)
|
|
|
|
viewGenomeButton := widget.NewButtonWithIcon("", theme.VisibilityIcon(), func(){
|
|
setViewPersonGenomePolygenicDiseaseLociPage(window, personAnalysisMapList, diseaseName, personAnalysisGenomeIdentifier, genomeName, currentPage)
|
|
})
|
|
|
|
personNameColumn.Add(personNameLabel)
|
|
genomeNameColumn.Add(genomeNameLabel)
|
|
riskScoreColumn.Add(genomeRiskScoreLabel)
|
|
numberOfLociTestedColumn.Add(numberOfLociTestedText)
|
|
viewGenomeButtonsColumn.Add(viewGenomeButton)
|
|
|
|
personNameColumn.Add(widget.NewSeparator())
|
|
genomeNameColumn.Add(widget.NewSeparator())
|
|
riskScoreColumn.Add(widget.NewSeparator())
|
|
numberOfLociTestedColumn.Add(widget.NewSeparator())
|
|
viewGenomeButtonsColumn.Add(widget.NewSeparator())
|
|
|
|
return nil
|
|
}
|
|
|
|
personAGenomeIdentifier, personBGenomeIdentifier, found := strings.Cut(genomePairIdentifier, "+")
|
|
if (found == false){
|
|
setErrorEncounteredPage(window, errors.New("setViewCoupleGeneticAnalysisPolygenicDiseaseGenomePairDetailsPage called with invalid genomePairIdentifier"), previousPage)
|
|
return
|
|
}
|
|
|
|
err := addGenomeRow(true, personAName, personAGenomeIdentifier)
|
|
if (err != nil){
|
|
setErrorEncounteredPage(window, err, previousPage)
|
|
return
|
|
}
|
|
err = addGenomeRow(false, personBName, personBGenomeIdentifier)
|
|
if (err != nil){
|
|
setErrorEncounteredPage(window, err, previousPage)
|
|
return
|
|
}
|
|
|
|
riskScoreHelpButton := widget.NewButtonWithIcon("", theme.QuestionIcon(), func(){
|
|
setPolygenicDiseaseRiskScoreExplainerPage(window, currentPage)
|
|
})
|
|
|
|
riskScoreColumn.Add(riskScoreHelpButton)
|
|
|
|
numberOfLociTestedHelpButton := widget.NewButtonWithIcon("", theme.QuestionIcon(), func(){
|
|
setPolygenicDiseaseNumberOfLociTestedExplainerPage(window, currentPage)
|
|
})
|
|
numberOfLociTestedColumn.Add(numberOfLociTestedHelpButton)
|
|
|
|
genomesGrid := container.NewHBox(layout.NewSpacer(), personNameColumn, genomeNameColumn, riskScoreColumn, numberOfLociTestedColumn, viewGenomeButtonsColumn, layout.NewSpacer())
|
|
|
|
page := container.NewVBox(title, backButton, widget.NewSeparator(), description, widget.NewSeparator(), diseaseNameRow, widget.NewSeparator(), genomePairRow, widget.NewSeparator(), genomesGrid)
|
|
|
|
setPageContent(page, window)
|
|
}
|
|
|
|
|
|
// This function provides a page to view the couple offspring locus probabilities for a particular genome pair
|
|
func setViewCouplePolygenicDiseaseLociPage(window fyne.Window, personAName string, personBName string, personAAnalysisMapList []map[string]string, personBAnalysisMapList []map[string]string, coupleAnalysisMapList []map[string]string, diseaseName string, genomePairIdentifier string, genomePairName string, previousPage func()){
|
|
|
|
setLoadingScreen(window, "Loading Polygenic Disease Loci", "Loading disease loci...")
|
|
|
|
currentPage := func(){setViewCouplePolygenicDiseaseLociPage(window, personAName, personBName, personAAnalysisMapList, personBAnalysisMapList, coupleAnalysisMapList, diseaseName, genomePairIdentifier, genomePairName, previousPage)}
|
|
|
|
title := getPageTitleCentered("View Offspring Disease Loci - " + diseaseName)
|
|
|
|
backButton := getBackButtonCentered(previousPage)
|
|
|
|
description1 := widget.NewLabel("Below are the disease loci probabilities for offspring from this genome pair.")
|
|
diseaseLociHelpButton := widget.NewButtonWithIcon("", theme.QuestionIcon(), func(){
|
|
setPolygenicDiseaseLociExplainerPage(window, currentPage)
|
|
})
|
|
description1Row := container.NewHBox(layout.NewSpacer(), description1, diseaseLociHelpButton, layout.NewSpacer())
|
|
|
|
genomePairLabel := widget.NewLabel("Genome Pair:")
|
|
genomePairNameLabel := getBoldLabel(genomePairName)
|
|
viewGenomePairInfoButton := widget.NewButtonWithIcon("", theme.InfoIcon(), func(){
|
|
setViewCoupleGeneticAnalysisPolygenicDiseaseGenomePairDetailsPage(window, personAName, personBName, personAAnalysisMapList, personBAnalysisMapList, coupleAnalysisMapList, diseaseName, genomePairIdentifier, genomePairName, currentPage)
|
|
})
|
|
|
|
genomePairRow := container.NewHBox(layout.NewSpacer(), genomePairLabel, genomePairNameLabel, viewGenomePairInfoButton, layout.NewSpacer())
|
|
|
|
_, _, secondGenomePairExists, _, _, _, _, _, _, _, _, err := readGeneticAnalysis.GetMetadataFromCoupleGeneticAnalysis(coupleAnalysisMapList)
|
|
if (err != nil){
|
|
setErrorEncounteredPage(window, err, previousPage)
|
|
return
|
|
}
|
|
|
|
_, _, _, numberOfLociTested, _, err := readGeneticAnalysis.GetOffspringPolygenicDiseaseInfoFromGeneticAnalysis(coupleAnalysisMapList, diseaseName, genomePairIdentifier, secondGenomePairExists)
|
|
if (err != nil){
|
|
setErrorEncounteredPage(window, err, previousPage)
|
|
return
|
|
}
|
|
|
|
numberOfLociTestedString := helpers.ConvertIntToString(numberOfLociTested)
|
|
|
|
diseaseLociMap, err := polygenicDiseases.GetPolygenicDiseaseLociMap(diseaseName)
|
|
if (err != nil){
|
|
setErrorEncounteredPage(window, err, previousPage)
|
|
return
|
|
}
|
|
|
|
totalNumberOfLoci := len(diseaseLociMap)
|
|
totalNumberOfLociString := helpers.ConvertIntToString(totalNumberOfLoci)
|
|
|
|
lociTestedLabel := widget.NewLabel("Loci Tested:")
|
|
lociTestedText := getBoldLabel(numberOfLociTestedString + "/" + totalNumberOfLociString)
|
|
lociTestedHelpButton := widget.NewButtonWithIcon("", theme.QuestionIcon(), func(){
|
|
setOffspringPolygenicDiseaseNumberOfLociTestedExplainerPage(window, currentPage)
|
|
})
|
|
|
|
lociTestedRow := container.NewHBox(layout.NewSpacer(), lociTestedLabel, lociTestedText, lociTestedHelpButton, layout.NewSpacer())
|
|
|
|
getLociGrid := func()(*fyne.Container, error){
|
|
|
|
locusNameLabel := getItalicLabelCentered("Locus Name")
|
|
|
|
offspringRiskWeightLabel := getItalicLabelCentered("Offspring Risk Weight")
|
|
|
|
offspringOddsRatioLabel := getItalicLabelCentered("Offspring Odds Ratio")
|
|
|
|
emptyLabel := widget.NewLabel("")
|
|
|
|
locusNameColumn := container.NewVBox(locusNameLabel, widget.NewSeparator())
|
|
offspringRiskWeightColumn := container.NewVBox(offspringRiskWeightLabel, widget.NewSeparator())
|
|
offspringOddsRatioColumn := container.NewVBox(offspringOddsRatioLabel, widget.NewSeparator())
|
|
lociInfoButtonsColumn := container.NewVBox(emptyLabel, widget.NewSeparator())
|
|
|
|
addLocusRow := func(locusIdentifier string)error{
|
|
|
|
locusObject, exists := diseaseLociMap[locusIdentifier]
|
|
if (exists == false) {
|
|
return errors.New("Cannot add locus row: Locus not found in diseaseLociMap: " + locusIdentifier)
|
|
}
|
|
|
|
locusRSID := locusObject.LocusRSID
|
|
locusRSIDString := helpers.ConvertInt64ToString(locusRSID)
|
|
locusName := "rs" + locusRSIDString
|
|
|
|
offspringRiskWeightKnown, offspringRiskWeight, offspringOddsRatioKnown, _, offspringOddsRatioFormatted, err := readGeneticAnalysis.GetOffspringPolygenicDiseaseLocusInfoFromGeneticAnalysis(coupleAnalysisMapList, diseaseName, locusIdentifier, genomePairIdentifier)
|
|
if (err != nil) { return err }
|
|
|
|
getOffspringRiskWeightText := func()string{
|
|
|
|
if (offspringRiskWeightKnown == false){
|
|
|
|
unknownTextTranslated := translate("Unknown")
|
|
return unknownTextTranslated
|
|
}
|
|
|
|
offspringRiskWeightString := helpers.ConvertIntToString(offspringRiskWeight)
|
|
|
|
return offspringRiskWeightString
|
|
}
|
|
|
|
offspringRiskWeightText := getOffspringRiskWeightText()
|
|
|
|
getOffspringOddsRatioText := func()string{
|
|
|
|
if (offspringOddsRatioKnown == false){
|
|
|
|
unknownTextTranslated := translate("Unknown")
|
|
return unknownTextTranslated
|
|
}
|
|
|
|
return offspringOddsRatioFormatted
|
|
}
|
|
|
|
offspringOddsRatioText := getOffspringOddsRatioText()
|
|
|
|
locusNameLabel := getBoldLabelCentered(locusName)
|
|
|
|
locusRiskWeightLabel := getBoldLabelCentered(offspringRiskWeightText)
|
|
locusOddsRatioLabel := getBoldLabelCentered(offspringOddsRatioText)
|
|
|
|
viewLocusDetailsButton := widget.NewButtonWithIcon("", theme.VisibilityIcon(), func(){
|
|
setViewCoupleGeneticAnalysisPolygenicDiseaseLocusDetailsPage(window, personAName, personBName, personAAnalysisMapList, personBAnalysisMapList, coupleAnalysisMapList, diseaseName, locusIdentifier, currentPage)
|
|
})
|
|
|
|
locusNameColumn.Add(locusNameLabel)
|
|
offspringRiskWeightColumn.Add(locusRiskWeightLabel)
|
|
offspringOddsRatioColumn.Add(locusOddsRatioLabel)
|
|
lociInfoButtonsColumn.Add(viewLocusDetailsButton)
|
|
|
|
locusNameColumn.Add(widget.NewSeparator())
|
|
offspringRiskWeightColumn.Add(widget.NewSeparator())
|
|
offspringOddsRatioColumn.Add(widget.NewSeparator())
|
|
lociInfoButtonsColumn.Add(widget.NewSeparator())
|
|
|
|
return nil
|
|
}
|
|
|
|
lociWithKnownRiskWeightList := make([]string, 0)
|
|
lociWithUnknownRiskWeightList := make([]string, 0)
|
|
|
|
for locusIdentifier, _ := range diseaseLociMap{
|
|
|
|
offspringRiskWeightKnown, _, _, _, _, err := readGeneticAnalysis.GetOffspringPolygenicDiseaseLocusInfoFromGeneticAnalysis(coupleAnalysisMapList, diseaseName, locusIdentifier, genomePairIdentifier)
|
|
if (err != nil) { return nil, err }
|
|
|
|
if (offspringRiskWeightKnown == true){
|
|
lociWithKnownRiskWeightList = append(lociWithKnownRiskWeightList, locusIdentifier)
|
|
} else {
|
|
lociWithUnknownRiskWeightList = append(lociWithUnknownRiskWeightList, locusIdentifier)
|
|
}
|
|
}
|
|
|
|
// We sort the lists so loci show up in the same order whenever page is refreshed
|
|
|
|
helpers.SortStringListToUnicodeOrder(lociWithKnownRiskWeightList)
|
|
helpers.SortStringListToUnicodeOrder(lociWithUnknownRiskWeightList)
|
|
|
|
for _, locusIdentifier := range lociWithKnownRiskWeightList{
|
|
|
|
err = addLocusRow(locusIdentifier)
|
|
if (err != nil) { return nil, err }
|
|
}
|
|
|
|
for _, locusIdentifier := range lociWithUnknownRiskWeightList{
|
|
|
|
err = addLocusRow(locusIdentifier)
|
|
if (err != nil) { return nil, err }
|
|
}
|
|
|
|
offspringRiskWeightHelpButton := widget.NewButtonWithIcon("", theme.QuestionIcon(), func(){
|
|
setOffspringPolygenicDiseaseLocusRiskWeightExplainerPage(window, currentPage)
|
|
})
|
|
offspringRiskWeightColumn.Add(offspringRiskWeightHelpButton)
|
|
|
|
offspringOddsRatioHelpButton := widget.NewButtonWithIcon("", theme.QuestionIcon(), func(){
|
|
//TODO
|
|
showUnderConstructionDialog(window)
|
|
})
|
|
offspringOddsRatioColumn.Add(offspringOddsRatioHelpButton)
|
|
|
|
lociGrid := container.NewHBox(layout.NewSpacer(), locusNameColumn, offspringRiskWeightColumn, offspringOddsRatioColumn, lociInfoButtonsColumn, layout.NewSpacer())
|
|
|
|
return lociGrid, nil
|
|
}
|
|
|
|
lociGrid, err := getLociGrid()
|
|
if (err != nil){
|
|
setErrorEncounteredPage(window, err, previousPage)
|
|
return
|
|
}
|
|
|
|
page := container.NewVBox(title, backButton, widget.NewSeparator(), description1Row, widget.NewSeparator(), genomePairRow, widget.NewSeparator(), lociTestedRow, widget.NewSeparator(), lociGrid)
|
|
|
|
setPageContent(page, window)
|
|
}
|
|
|
|
|
|
// This function provides a page to view the details of a specific locus from a genetic analysis
|
|
// It will show the locus details for all of the couple's genome pairs
|
|
func setViewCoupleGeneticAnalysisPolygenicDiseaseLocusDetailsPage(window fyne.Window, personAName string, personBName string, personAAnalysisMapList []map[string]string, personBAnalysisMapList []map[string]string, coupleAnalysisMapList []map[string]string, diseaseName string, locusIdentifier string, previousPage func()){
|
|
|
|
currentPage := func(){setViewCoupleGeneticAnalysisPolygenicDiseaseLocusDetailsPage(window, personAName, personBName, personAAnalysisMapList, personBAnalysisMapList, coupleAnalysisMapList, diseaseName, locusIdentifier, previousPage)}
|
|
|
|
title := getPageTitleCentered("Disease Locus Details - " + diseaseName)
|
|
|
|
backButton := getBackButtonCentered(previousPage)
|
|
|
|
locusObject, err := polygenicDiseases.GetPolygenicDiseaseLocusObject(diseaseName, locusIdentifier)
|
|
if (err != nil) {
|
|
setErrorEncounteredPage(window, err, previousPage)
|
|
return
|
|
}
|
|
|
|
locusRSID := locusObject.LocusRSID
|
|
locusRSIDString := helpers.ConvertInt64ToString(locusRSID)
|
|
locusName := "rs" + locusRSIDString
|
|
|
|
description := getLabelCentered("Below is the locus analysis for the couple.")
|
|
|
|
locusNameLabel := widget.NewLabel("Locus Name:")
|
|
locusNameText := getBoldLabel(locusName)
|
|
locusInfoButton := widget.NewButtonWithIcon("", theme.InfoIcon(), func(){
|
|
setViewPolygenicDiseaseLocusDetailsPage(window, diseaseName, locusIdentifier, currentPage)
|
|
})
|
|
locusNameRow := container.NewHBox(layout.NewSpacer(), locusNameLabel, locusNameText, locusInfoButton, layout.NewSpacer())
|
|
|
|
getGenomePairsLocusInfoGrid := func()(*fyne.Container, error){
|
|
|
|
emptyLabel := widget.NewLabel("")
|
|
|
|
genomePairLabel := getItalicLabelCentered("Genome Pair")
|
|
|
|
offspringRiskWeightLabel := getItalicLabelCentered("Offspring Risk Weight")
|
|
|
|
offspringOddsRatioLabel := getItalicLabelCentered("Offspring Odds Ratio")
|
|
|
|
viewGenomePairInfoButtonsColumn := container.NewVBox(emptyLabel, widget.NewSeparator())
|
|
genomePairNameColumn := container.NewVBox(genomePairLabel, widget.NewSeparator())
|
|
offspringRiskWeightColumn := container.NewVBox(offspringRiskWeightLabel, widget.NewSeparator())
|
|
offspringOddsRatioColumn := container.NewVBox(offspringOddsRatioLabel, widget.NewSeparator())
|
|
|
|
addGenomePairRow := func(genomePairName string, genomePairIdentifier string)error{
|
|
|
|
offspringRiskWeightKnown, offspringRiskWeight, offspringOddsRatioKnown, _, offspringOddsRatioFormatted, err := readGeneticAnalysis.GetOffspringPolygenicDiseaseLocusInfoFromGeneticAnalysis(coupleAnalysisMapList, diseaseName, locusIdentifier, genomePairIdentifier)
|
|
if (err != nil) { return err }
|
|
|
|
getOffspringRiskWeightText := func()string{
|
|
|
|
if (offspringRiskWeightKnown == false){
|
|
result := translate("Unknown")
|
|
return result
|
|
}
|
|
|
|
offspringRiskWeightString := helpers.ConvertIntToString(offspringRiskWeight)
|
|
|
|
return offspringRiskWeightString
|
|
}
|
|
|
|
offspringRiskWeightText := getOffspringRiskWeightText()
|
|
|
|
getOffspringOddsRatioText := func()string{
|
|
if (offspringOddsRatioKnown == false){
|
|
result := translate("Unknown")
|
|
return result
|
|
}
|
|
return offspringOddsRatioFormatted
|
|
}
|
|
|
|
offspringOddsRatioText := getOffspringOddsRatioText()
|
|
|
|
viewGenomePairInfoButton := widget.NewButtonWithIcon("", theme.InfoIcon(), func(){
|
|
setViewCoupleGeneticAnalysisPolygenicDiseaseGenomePairDetailsPage(window, personAName, personBName, personAAnalysisMapList, personBAnalysisMapList, coupleAnalysisMapList, diseaseName, genomePairIdentifier, genomePairName, currentPage)
|
|
})
|
|
|
|
genomePairNameLabel := getBoldLabelCentered(genomePairName)
|
|
|
|
offspringRiskWeightLabel := getBoldLabelCentered(offspringRiskWeightText)
|
|
offspringOddsRatioLabel := getBoldLabelCentered(offspringOddsRatioText)
|
|
|
|
viewGenomePairInfoButtonsColumn.Add(viewGenomePairInfoButton)
|
|
genomePairNameColumn.Add(genomePairNameLabel)
|
|
offspringRiskWeightColumn.Add(offspringRiskWeightLabel)
|
|
offspringOddsRatioColumn.Add(offspringOddsRatioLabel)
|
|
|
|
viewGenomePairInfoButtonsColumn.Add(widget.NewSeparator())
|
|
genomePairNameColumn.Add(widget.NewSeparator())
|
|
offspringRiskWeightColumn.Add(widget.NewSeparator())
|
|
offspringOddsRatioColumn.Add(widget.NewSeparator())
|
|
|
|
return nil
|
|
}
|
|
|
|
pair1PersonAGenomeIdentifier, pair1PersonBGenomeIdentifier, secondGenomePairExists, pair2PersonAGenomeIdentifier, pair2PersonBGenomeIdentifier, _, _, _, _, _, _, err := readGeneticAnalysis.GetMetadataFromCoupleGeneticAnalysis(coupleAnalysisMapList)
|
|
if (err != nil){ return nil, err }
|
|
|
|
genomePair1Identifier := pair1PersonAGenomeIdentifier + "+" + pair1PersonBGenomeIdentifier
|
|
|
|
err = addGenomePairRow("Pair 1", genomePair1Identifier)
|
|
if (err != nil) { return nil, err }
|
|
|
|
if (secondGenomePairExists == true){
|
|
|
|
genomePair2Identifier := pair2PersonAGenomeIdentifier + "+" + pair2PersonBGenomeIdentifier
|
|
|
|
err := addGenomePairRow("Pair 2", genomePair2Identifier)
|
|
if (err != nil) { return nil, err }
|
|
}
|
|
|
|
offspringRiskWeightHelpButton := widget.NewButtonWithIcon("", theme.QuestionIcon(), func(){
|
|
setOffspringPolygenicDiseaseLocusRiskWeightExplainerPage(window, currentPage)
|
|
})
|
|
|
|
offspringOddsRatioHelpButton := widget.NewButtonWithIcon("", theme.QuestionIcon(), func(){
|
|
//TODO
|
|
showUnderConstructionDialog(window)
|
|
})
|
|
|
|
offspringRiskWeightColumn.Add(offspringRiskWeightHelpButton)
|
|
offspringOddsRatioColumn.Add(offspringOddsRatioHelpButton)
|
|
|
|
genomesContainer := container.NewHBox(layout.NewSpacer(), viewGenomePairInfoButtonsColumn, genomePairNameColumn, offspringRiskWeightColumn, offspringOddsRatioColumn, layout.NewSpacer())
|
|
|
|
return genomesContainer, nil
|
|
}
|
|
|
|
genomePairsLocusInfoGrid, err := getGenomePairsLocusInfoGrid()
|
|
if (err != nil){
|
|
setErrorEncounteredPage(window, err, previousPage)
|
|
return
|
|
}
|
|
|
|
page := container.NewVBox(title, backButton, widget.NewSeparator(), description, widget.NewSeparator(), locusNameRow, widget.NewSeparator(), genomePairsLocusInfoGrid)
|
|
|
|
setPageContent(page, window)
|
|
}
|
|
|
|
|
|
func setViewCoupleGeneticAnalysisTraitsPage(window fyne.Window, personAName string, personBName string, personAAnalysisMapList []map[string]string, personBAnalysisMapList []map[string]string, coupleAnalysisMapList []map[string]string, previousPage func()){
|
|
|
|
currentPage := func(){setViewCoupleGeneticAnalysisTraitsPage(window, personAName, personBName, personAAnalysisMapList, personBAnalysisMapList, coupleAnalysisMapList, previousPage)}
|
|
|
|
title := getPageTitleCentered("Viewing Genetic Analysis - Traits")
|
|
|
|
backButton := getBackButtonCentered(previousPage)
|
|
|
|
description := getLabelCentered("Below is an analysis of the average trait scores for the couple's offspring.")
|
|
|
|
getTraitsGrid := func()(*fyne.Container, error){
|
|
|
|
pair1PersonAGenomeIdentifier, pair1PersonBGenomeIdentifier, secondGenomePairExists, _, _, _, _, _, _, _, _, err := readGeneticAnalysis.GetMetadataFromCoupleGeneticAnalysis(coupleAnalysisMapList)
|
|
if (err != nil){ return nil, err }
|
|
|
|
traitNameLabel := getItalicLabelCentered("Trait Name")
|
|
|
|
offspringOutcomeScoresLabel := getItalicLabelCentered("Offspring Outcome Scores")
|
|
|
|
conflictExistsLabel := getItalicLabelCentered("Conflict Exists?")
|
|
|
|
emptyLabel := widget.NewLabel("")
|
|
|
|
traitNameColumn := container.NewVBox(traitNameLabel, widget.NewSeparator())
|
|
offspringOutcomeScoresColumn := container.NewVBox(offspringOutcomeScoresLabel, widget.NewSeparator())
|
|
conflictExistsColumn := container.NewVBox(conflictExistsLabel, widget.NewSeparator())
|
|
viewButtonsColumn := container.NewVBox(emptyLabel, widget.NewSeparator())
|
|
|
|
traitObjectsList, err := traits.GetTraitObjectsList()
|
|
if (err != nil) { return nil, err }
|
|
|
|
for _, traitObject := range traitObjectsList{
|
|
|
|
traitName := traitObject.TraitName
|
|
|
|
traitRulesList := traitObject.RulesList
|
|
|
|
if (len(traitRulesList) == 0){
|
|
// This trait does not have any rules
|
|
// We cannot analyze it yet
|
|
// We will add neural network prediction so we can predict these traits
|
|
continue
|
|
}
|
|
|
|
mainGenomePairIdentifier := pair1PersonAGenomeIdentifier + "+" + pair1PersonBGenomeIdentifier
|
|
|
|
offspringOutcomeScoresKnown, offspringAverageOutcomeScoresMap, _, conflictExists, err := readGeneticAnalysis.GetOffspringTraitInfoFromGeneticAnalysis(coupleAnalysisMapList, traitName, mainGenomePairIdentifier, secondGenomePairExists)
|
|
if (err != nil) { return nil, err }
|
|
|
|
// We add all of the columns except for the trait outcomes column, which may be multiple rows high
|
|
|
|
traitNameText := getBoldLabelCentered(traitName)
|
|
|
|
conflictExistsString := helpers.ConvertBoolToYesOrNoString(conflictExists)
|
|
conflictExistsLabel := getBoldLabelCentered(conflictExistsString)
|
|
|
|
viewDetailsButton := getWidgetCentered(widget.NewButtonWithIcon("", theme.VisibilityIcon(), func(){
|
|
setViewCoupleGeneticAnalysisTraitDetailsPage(window, personAName, personBName, personAAnalysisMapList, personBAnalysisMapList, coupleAnalysisMapList, traitName, previousPage)
|
|
}))
|
|
|
|
traitNameColumn.Add(traitNameText)
|
|
conflictExistsColumn.Add(conflictExistsLabel)
|
|
viewButtonsColumn.Add(viewDetailsButton)
|
|
|
|
if (offspringOutcomeScoresKnown == false){
|
|
|
|
unknownTranslated := translate("Unknown")
|
|
unknownLabel := getBoldLabelCentered(unknownTranslated)
|
|
|
|
offspringOutcomeScoresColumn.Add(unknownLabel)
|
|
} else {
|
|
|
|
outcomeNamesList := helpers.GetListOfMapKeys(offspringAverageOutcomeScoresMap)
|
|
|
|
// We have to sort outcome names so they always show up in the same order
|
|
helpers.SortStringListToUnicodeOrder(outcomeNamesList)
|
|
|
|
for index, outcomeName := range outcomeNamesList{
|
|
|
|
outcomeScore, exists := offspringAverageOutcomeScoresMap[outcomeName]
|
|
if (exists == false){
|
|
return nil, errors.New("Outcome name not found in outcomeScoresMap after being found already.")
|
|
}
|
|
|
|
outcomeScoreString := helpers.ConvertFloat64ToStringRounded(outcomeScore, 2)
|
|
|
|
outcomeRow := getBoldLabelCentered(outcomeName + ": " + outcomeScoreString)
|
|
offspringOutcomeScoresColumn.Add(outcomeRow)
|
|
|
|
if (index > 0){
|
|
|
|
emptyLabelA := widget.NewLabel("")
|
|
emptyLabelB := widget.NewLabel("")
|
|
emptyLabelC := widget.NewLabel("")
|
|
|
|
traitNameColumn.Add(emptyLabelA)
|
|
conflictExistsColumn.Add(emptyLabelB)
|
|
viewButtonsColumn.Add(emptyLabelC)
|
|
}
|
|
}
|
|
}
|
|
|
|
traitNameColumn.Add(widget.NewSeparator())
|
|
offspringOutcomeScoresColumn.Add(widget.NewSeparator())
|
|
conflictExistsColumn.Add(widget.NewSeparator())
|
|
viewButtonsColumn.Add(widget.NewSeparator())
|
|
}
|
|
|
|
offspringOutcomeScoresHelpButton := widget.NewButtonWithIcon("", theme.QuestionIcon(), func(){
|
|
setOffspringTraitOutcomeScoresExplainerPage(window, currentPage)
|
|
})
|
|
offspringOutcomeScoresColumn.Add(offspringOutcomeScoresHelpButton)
|
|
|
|
traitsGrid := container.NewHBox(layout.NewSpacer(), traitNameColumn, offspringOutcomeScoresColumn)
|
|
|
|
if (secondGenomePairExists == true){
|
|
|
|
conflictExistsHelpButton := widget.NewButtonWithIcon("", theme.QuestionIcon(), func(){
|
|
setCoupleGeneticAnalysisConflictExistsExplainerPage(window, currentPage)
|
|
})
|
|
conflictExistsColumn.Add(conflictExistsHelpButton)
|
|
|
|
traitsGrid.Add(conflictExistsColumn)
|
|
}
|
|
|
|
traitsGrid.Add(viewButtonsColumn)
|
|
traitsGrid.Add(layout.NewSpacer())
|
|
|
|
return traitsGrid, nil
|
|
}
|
|
|
|
traitsGrid, err := getTraitsGrid()
|
|
if (err != nil){
|
|
setErrorEncounteredPage(window, err, previousPage)
|
|
return
|
|
}
|
|
|
|
page := container.NewVBox(title, backButton, widget.NewSeparator(), description, widget.NewSeparator(), traitsGrid)
|
|
|
|
setPageContent(page, window)
|
|
}
|
|
|
|
|
|
|
|
func setViewCoupleGeneticAnalysisTraitDetailsPage(window fyne.Window, personAName string, personBName string, personAAnalysisMapList []map[string]string, personBAnalysisMapList []map[string]string, coupleAnalysisMapList []map[string]string, traitName string, previousPage func()){
|
|
|
|
currentPage := func(){setViewCoupleGeneticAnalysisTraitDetailsPage(window, personAName, personBName, personAAnalysisMapList, personBAnalysisMapList, coupleAnalysisMapList, traitName, previousPage)}
|
|
|
|
title := getPageTitleCentered("Viewing Couple Analysis - " + traitName)
|
|
|
|
backButton := getBackButtonCentered(previousPage)
|
|
|
|
pair1PersonAGenomeIdentifier, pair1PersonBGenomeIdentifier, secondGenomePairExists, pair2PersonAGenomeIdentifier, pair2PersonBGenomeIdentifier, _, _, _, _, _, _, err := readGeneticAnalysis.GetMetadataFromCoupleGeneticAnalysis(coupleAnalysisMapList)
|
|
if (err != nil){
|
|
setErrorEncounteredPage(window, err, previousPage)
|
|
return
|
|
}
|
|
|
|
getDescriptionSection := func()*fyne.Container{
|
|
|
|
if (secondGenomePairExists == false){
|
|
description := getLabelCentered("Below is the trait analysis for the couple's offspring.")
|
|
|
|
return description
|
|
}
|
|
|
|
description1 := getLabelCentered("Below is the trait analysis for the couple's offspring.")
|
|
description2 := getLabelCentered("Each genome pair combines different genomes from each person.")
|
|
|
|
descriptionsSection := container.NewVBox(description1, description2)
|
|
|
|
return descriptionsSection
|
|
}
|
|
|
|
descriptionSection := getDescriptionSection()
|
|
|
|
traitNameLabel := widget.NewLabel("Trait:")
|
|
traitNameText := getBoldLabel(traitName)
|
|
traitNameInfoButton := widget.NewButtonWithIcon("", theme.InfoIcon(), func(){
|
|
setViewTraitDetailsPage(window, traitName, currentPage)
|
|
})
|
|
traitNameRow := container.NewHBox(layout.NewSpacer(), traitNameLabel, traitNameText, traitNameInfoButton, layout.NewSpacer())
|
|
|
|
emptyLabelA := widget.NewLabel("")
|
|
emptyLabelB := widget.NewLabel("")
|
|
|
|
offspringOutcomeScoresLabel := getItalicLabelCentered("Offspring Outcome Scores")
|
|
|
|
emptyLabelC := widget.NewLabel("")
|
|
|
|
viewGenomePairButtonsColumn := container.NewVBox(emptyLabelA, widget.NewSeparator())
|
|
pairNameColumn := container.NewVBox(emptyLabelB, widget.NewSeparator())
|
|
offspringOutcomeScoresColumn := container.NewVBox(offspringOutcomeScoresLabel, widget.NewSeparator())
|
|
viewOffspringRulesButtonsColumn := container.NewVBox(emptyLabelC, widget.NewSeparator())
|
|
|
|
addGenomePairRow := func(genomePairName string, personAGenomeIdentifier string, personBGenomeIdentifier string)error{
|
|
|
|
genomePairIdentifier := personAGenomeIdentifier + "+" + personBGenomeIdentifier
|
|
|
|
genomePairNameLabel := getBoldLabelCentered(genomePairName)
|
|
|
|
viewGenomePairButton := widget.NewButtonWithIcon("", theme.InfoIcon(), func(){
|
|
setViewCoupleGeneticAnalysisTraitGenomePairDetailsPage(window, personAName, personBName, personAAnalysisMapList, personBAnalysisMapList, coupleAnalysisMapList, traitName, genomePairIdentifier, genomePairName, currentPage)
|
|
})
|
|
|
|
|
|
viewOffspringRulesButton := widget.NewButtonWithIcon("", theme.VisibilityIcon(), func(){
|
|
setViewCoupleTraitRulesPage(window, personAName, personBName, personAAnalysisMapList, personBAnalysisMapList, coupleAnalysisMapList, traitName, genomePairIdentifier, genomePairName, currentPage)
|
|
})
|
|
|
|
// We add all of the columns except for the trait rule column, which may be multiple rows high
|
|
|
|
viewGenomePairButtonsColumn.Add(viewGenomePairButton)
|
|
pairNameColumn.Add(genomePairNameLabel)
|
|
viewOffspringRulesButtonsColumn.Add(viewOffspringRulesButton)
|
|
|
|
offspringOutcomeScoresKnown, offspringOutcomeScoresMap, _, _, err := readGeneticAnalysis.GetOffspringTraitInfoFromGeneticAnalysis(coupleAnalysisMapList, traitName, genomePairIdentifier, secondGenomePairExists)
|
|
if (err != nil) { return err }
|
|
if (offspringOutcomeScoresKnown == false){
|
|
|
|
unknownTranslated := translate("Unknown")
|
|
unknownLabel := getBoldLabelCentered(unknownTranslated)
|
|
|
|
offspringOutcomeScoresColumn.Add(unknownLabel)
|
|
|
|
} else {
|
|
|
|
outcomeNamesList := helpers.GetListOfMapKeys(offspringOutcomeScoresMap)
|
|
|
|
// We have to sort the outcome names so they always show up in the same order
|
|
helpers.SortStringListToUnicodeOrder(outcomeNamesList)
|
|
|
|
for index, outcomeName := range outcomeNamesList{
|
|
|
|
outcomeScore, exists := offspringOutcomeScoresMap[outcomeName]
|
|
if (exists == false){
|
|
return errors.New("Outcome name not found in outcome scores map after being found already.")
|
|
}
|
|
|
|
outcomeScoreString := helpers.ConvertFloat64ToStringRounded(outcomeScore, 2)
|
|
|
|
outcomeRow := getBoldLabelCentered(outcomeName + ": " + outcomeScoreString)
|
|
offspringOutcomeScoresColumn.Add(outcomeRow)
|
|
|
|
if (index > 0){
|
|
|
|
emptyLabelA := widget.NewLabel("")
|
|
emptyLabelB := widget.NewLabel("")
|
|
emptyLabelC := widget.NewLabel("")
|
|
|
|
pairNameColumn.Add(emptyLabelA)
|
|
viewGenomePairButtonsColumn.Add(emptyLabelB)
|
|
viewOffspringRulesButtonsColumn.Add(emptyLabelC)
|
|
}
|
|
}
|
|
}
|
|
|
|
viewGenomePairButtonsColumn.Add(widget.NewSeparator())
|
|
pairNameColumn.Add(widget.NewSeparator())
|
|
offspringOutcomeScoresColumn.Add(widget.NewSeparator())
|
|
viewOffspringRulesButtonsColumn.Add(widget.NewSeparator())
|
|
|
|
return nil
|
|
}
|
|
|
|
err = addGenomePairRow("Pair 1", pair1PersonAGenomeIdentifier, pair1PersonBGenomeIdentifier)
|
|
if (err != nil) {
|
|
setErrorEncounteredPage(window, err, previousPage)
|
|
return
|
|
}
|
|
|
|
if (secondGenomePairExists == true){
|
|
err := addGenomePairRow("Pair 2", pair2PersonAGenomeIdentifier, pair2PersonBGenomeIdentifier)
|
|
if (err != nil) {
|
|
setErrorEncounteredPage(window, err, previousPage)
|
|
return
|
|
}
|
|
}
|
|
|
|
offspringOutcomeScoresHelpButton := widget.NewButtonWithIcon("", theme.QuestionIcon(), func(){
|
|
setOffspringTraitOutcomeScoresExplainerPage(window, currentPage)
|
|
})
|
|
|
|
offspringOutcomeScoresColumn.Add(offspringOutcomeScoresHelpButton)
|
|
|
|
genomesContainer := container.NewHBox(layout.NewSpacer(), viewGenomePairButtonsColumn, pairNameColumn, offspringOutcomeScoresColumn, viewOffspringRulesButtonsColumn, layout.NewSpacer())
|
|
|
|
page := container.NewVBox(title, backButton, widget.NewSeparator(), descriptionSection, widget.NewSeparator(), traitNameRow, widget.NewSeparator(), genomesContainer)
|
|
|
|
setPageContent(page, window)
|
|
}
|
|
|
|
|
|
func setViewCoupleGeneticAnalysisTraitGenomePairDetailsPage(window fyne.Window, personAName string, personBName string, personAAnalysisMapList []map[string]string, personBAnalysisMapList []map[string]string, coupleAnalysisMapList []map[string]string, traitName string, genomePairIdentifier string, genomePairName string, previousPage func()){
|
|
|
|
currentPage := func(){setViewCoupleGeneticAnalysisTraitGenomePairDetailsPage(window, personAName, personBName, personAAnalysisMapList, personBAnalysisMapList, coupleAnalysisMapList, traitName, genomePairIdentifier, genomePairName, previousPage)}
|
|
|
|
title := getPageTitleCentered("Viewing Couple Genome Pair Info")
|
|
|
|
backButton := getBackButtonCentered(previousPage)
|
|
|
|
description := getLabelCentered("Below is the trait information for both genomes in the genome pair.")
|
|
|
|
traitNameLabel := widget.NewLabel("Trait:")
|
|
traitNameText := getBoldLabel(traitName)
|
|
traitNameInfoButton := widget.NewButtonWithIcon("", theme.InfoIcon(), func(){
|
|
setViewTraitDetailsPage(window, traitName, currentPage)
|
|
})
|
|
traitNameRow := container.NewHBox(layout.NewSpacer(), traitNameLabel, traitNameText, traitNameInfoButton, layout.NewSpacer())
|
|
|
|
genomePairLabel := widget.NewLabel("Genome Pair:")
|
|
genomePairNameLabel := getBoldLabel(genomePairName)
|
|
genomePairHelpButton := widget.NewButtonWithIcon("", theme.QuestionIcon(), func(){
|
|
setCoupleGenomePairExplainerPage(window, currentPage)
|
|
})
|
|
genomePairRow := container.NewHBox(layout.NewSpacer(), genomePairLabel, genomePairNameLabel, genomePairHelpButton, layout.NewSpacer())
|
|
|
|
emptyLabelA := widget.NewLabel("")
|
|
personNameLabel := getItalicLabelCentered("Person Name")
|
|
|
|
emptyLabelB := widget.NewLabel("")
|
|
genomeNameLabel := getItalicLabelCentered("Genome Name")
|
|
|
|
emptyLabelC := widget.NewLabel("")
|
|
outcomeScoresLabel := getItalicLabelCentered("Outcome Scores")
|
|
|
|
numberOfLabel := getItalicLabelCentered("Number Of")
|
|
rulesTestedLabel := getItalicLabelCentered("Rules Tested")
|
|
|
|
emptyLabelD := widget.NewLabel("")
|
|
emptyLabelE := widget.NewLabel("")
|
|
|
|
personNameColumn := container.NewVBox(emptyLabelA, personNameLabel, widget.NewSeparator())
|
|
genomeNameColumn := container.NewVBox(emptyLabelB, genomeNameLabel, widget.NewSeparator())
|
|
outcomeScoresColumn := container.NewVBox(emptyLabelC, outcomeScoresLabel, widget.NewSeparator())
|
|
numberOfRulesTestedColumn := container.NewVBox(numberOfLabel, rulesTestedLabel, widget.NewSeparator())
|
|
viewGenomeButtonsColumn := container.NewVBox(emptyLabelD, emptyLabelE, widget.NewSeparator())
|
|
|
|
addGenomeRow := func(isPersonA bool, personName string, inputGenomeIdentifier string)error{
|
|
|
|
personAnalysisGenomeIdentifier, personHasMultipleGenomes, genomeIsCombined, combinedType, err := readGeneticAnalysis.GetMatchingPersonAnalysisGenomeIdentifierFromCoupleAnalysis(isPersonA, personAAnalysisMapList, personBAnalysisMapList, coupleAnalysisMapList, inputGenomeIdentifier)
|
|
if (err != nil) { return err }
|
|
|
|
personNameTrimmed, _, err := helpers.TrimAndFlattenString(personName, 10)
|
|
if (err != nil) { return err }
|
|
|
|
personNameLabel := getBoldLabelCentered(personNameTrimmed)
|
|
|
|
getPersonAnalysisMapList := func()[]map[string]string{
|
|
if (isPersonA == true){
|
|
return personAAnalysisMapList
|
|
}
|
|
return personBAnalysisMapList
|
|
}
|
|
|
|
personAnalysisMapList := getPersonAnalysisMapList()
|
|
|
|
getGenomeName := func()(string, error){
|
|
|
|
if (genomeIsCombined == false){
|
|
|
|
genomeFound, _, _, _, _, _, companyName, _, _, err := myGenomes.GetMyRawGenomeMetadata(personAnalysisGenomeIdentifier)
|
|
if (err != nil) { return "", err }
|
|
if (genomeFound == false){
|
|
return "", errors.New("MyGenomeInfo for genome from analysisMapList not found.")
|
|
}
|
|
|
|
return companyName, nil
|
|
}
|
|
|
|
return combinedType, nil
|
|
}
|
|
|
|
genomeName, err := getGenomeName()
|
|
if (err != nil) { return err }
|
|
|
|
genomeNameLabel := getBoldLabelCentered(genomeName)
|
|
|
|
// We add all of the columns except for the trait rule column, which may be multiple rows high
|
|
|
|
_, anyTraitRuleTested, outcomeScoresMap, numberOfRulesTested, _, err := readGeneticAnalysis.GetPersonTraitInfoFromGeneticAnalysis(personAnalysisMapList, traitName, personAnalysisGenomeIdentifier, personHasMultipleGenomes)
|
|
if (err != nil) { return err }
|
|
|
|
numberOfRulesTestedString := helpers.ConvertIntToString(numberOfRulesTested)
|
|
numberOfRulesTestedText := getBoldLabelCentered(numberOfRulesTestedString)
|
|
|
|
viewGenomeButton := widget.NewButtonWithIcon("", theme.VisibilityIcon(), func(){
|
|
setViewPersonGenomeTraitRulesPage(window, personAnalysisMapList, traitName, personAnalysisGenomeIdentifier, genomeName, currentPage)
|
|
})
|
|
|
|
personNameColumn.Add(personNameLabel)
|
|
genomeNameColumn.Add(genomeNameLabel)
|
|
numberOfRulesTestedColumn.Add(numberOfRulesTestedText)
|
|
viewGenomeButtonsColumn.Add(viewGenomeButton)
|
|
|
|
if (anyTraitRuleTested == false){
|
|
|
|
unknownTranslated := translate("Unknown")
|
|
unknownLabel := getBoldLabelCentered(unknownTranslated)
|
|
|
|
outcomeScoresColumn.Add(unknownLabel)
|
|
|
|
} else {
|
|
|
|
outcomeNamesList := helpers.GetListOfMapKeys(outcomeScoresMap)
|
|
|
|
// We have to sort the outcome names so they always show up in the same order
|
|
helpers.SortStringListToUnicodeOrder(outcomeNamesList)
|
|
|
|
for index, outcomeName := range outcomeNamesList{
|
|
|
|
outcomeScore, exists := outcomeScoresMap[outcomeName]
|
|
if (exists == false){
|
|
return errors.New("Outcome name not found in outcome scores map after being found already.")
|
|
}
|
|
|
|
outcomeScoreString := helpers.ConvertIntToString(outcomeScore)
|
|
|
|
outcomeRow := getBoldLabelCentered(outcomeName + ": " + outcomeScoreString)
|
|
outcomeScoresColumn.Add(outcomeRow)
|
|
|
|
if (index > 0){
|
|
|
|
emptyLabelA := widget.NewLabel("")
|
|
emptyLabelB := widget.NewLabel("")
|
|
emptyLabelC := widget.NewLabel("")
|
|
emptyLabelD := widget.NewLabel("")
|
|
|
|
personNameColumn.Add(emptyLabelA)
|
|
genomeNameColumn.Add(emptyLabelB)
|
|
numberOfRulesTestedColumn.Add(emptyLabelC)
|
|
viewGenomeButtonsColumn.Add(emptyLabelD)
|
|
}
|
|
}
|
|
}
|
|
|
|
personNameColumn.Add(widget.NewSeparator())
|
|
genomeNameColumn.Add(widget.NewSeparator())
|
|
outcomeScoresColumn.Add(widget.NewSeparator())
|
|
numberOfRulesTestedColumn.Add(widget.NewSeparator())
|
|
viewGenomeButtonsColumn.Add(widget.NewSeparator())
|
|
|
|
return nil
|
|
}
|
|
|
|
personAGenomeIdentifier, personBGenomeIdentifier, found := strings.Cut(genomePairIdentifier, "+")
|
|
if (found == false){
|
|
setErrorEncounteredPage(window, errors.New("setViewCoupleGeneticAnalysisTraitGenomePairDetailsPage called with invalid genomePairIdentifier"), previousPage)
|
|
return
|
|
}
|
|
|
|
err := addGenomeRow(true, personAName, personAGenomeIdentifier)
|
|
if (err != nil){
|
|
setErrorEncounteredPage(window, err, previousPage)
|
|
return
|
|
}
|
|
err = addGenomeRow(false, personBName, personBGenomeIdentifier)
|
|
if (err != nil){
|
|
setErrorEncounteredPage(window, err, previousPage)
|
|
return
|
|
}
|
|
|
|
outcomeScoresHelpButton := widget.NewButtonWithIcon("", theme.QuestionIcon(), func(){
|
|
setOffspringTraitOutcomeScoresExplainerPage(window, currentPage)
|
|
})
|
|
|
|
outcomeScoresColumn.Add(outcomeScoresHelpButton)
|
|
|
|
numberOfRulesTestedHelpButton := widget.NewButtonWithIcon("", theme.QuestionIcon(), func(){
|
|
setOffspringTraitNumberOfRulesTestedExplainerPage(window, currentPage)
|
|
})
|
|
|
|
numberOfRulesTestedColumn.Add(numberOfRulesTestedHelpButton)
|
|
|
|
genomesGrid := container.NewHBox(layout.NewSpacer(), personNameColumn, genomeNameColumn, outcomeScoresColumn, numberOfRulesTestedColumn, viewGenomeButtonsColumn, layout.NewSpacer())
|
|
|
|
page := container.NewVBox(title, backButton, widget.NewSeparator(), description, traitNameRow, genomePairRow, widget.NewSeparator(), genomesGrid)
|
|
|
|
setPageContent(page, window)
|
|
}
|
|
|
|
|
|
|
|
// This function provides a page to view the couple offspring rule probabilities for a particular genome pair
|
|
func setViewCoupleTraitRulesPage(window fyne.Window, personAName string, personBName string, personAAnalysisMapList []map[string]string, personBAnalysisMapList []map[string]string, coupleAnalysisMapList []map[string]string, traitName string, genomePairIdentifier string, genomePairName string, previousPage func()){
|
|
|
|
setLoadingScreen(window, "Loading Trait Rules", "Loading trait rules...")
|
|
|
|
currentPage := func(){setViewCoupleTraitRulesPage(window, personAName, personBName, personAAnalysisMapList, personBAnalysisMapList, coupleAnalysisMapList, traitName, genomePairIdentifier, genomePairName, previousPage)}
|
|
|
|
title := getPageTitleCentered("View Offspring Trait Rules - " + traitName)
|
|
|
|
backButton := getBackButtonCentered(previousPage)
|
|
|
|
description1 := widget.NewLabel("Below are the trait rule probabilities for offspring from this genome pair.")
|
|
traitRulesHelpButton := widget.NewButtonWithIcon("", theme.QuestionIcon(), func(){
|
|
setOffspringTraitRulesExplainerPage(window, currentPage)
|
|
})
|
|
description1Row := container.NewHBox(layout.NewSpacer(), description1, traitRulesHelpButton, layout.NewSpacer())
|
|
|
|
genomePairLabel := widget.NewLabel("Genome Pair:")
|
|
genomePairNameLabel := getBoldLabel(genomePairName)
|
|
viewGenomePairInfoButton := widget.NewButtonWithIcon("", theme.InfoIcon(), func(){
|
|
setViewCoupleGeneticAnalysisTraitGenomePairDetailsPage(window, personAName, personBName, personAAnalysisMapList, personBAnalysisMapList, coupleAnalysisMapList, traitName, genomePairIdentifier, genomePairName, currentPage)
|
|
})
|
|
|
|
genomePairRow := container.NewHBox(layout.NewSpacer(), genomePairLabel, genomePairNameLabel, viewGenomePairInfoButton, layout.NewSpacer())
|
|
|
|
_, _, secondGenomePairExists, _, _, _, _, _, _, _, _, err := readGeneticAnalysis.GetMetadataFromCoupleGeneticAnalysis(coupleAnalysisMapList)
|
|
if (err != nil){
|
|
setErrorEncounteredPage(window, err, previousPage)
|
|
return
|
|
}
|
|
|
|
_, _, numberOfRulesTested, _, err := readGeneticAnalysis.GetOffspringTraitInfoFromGeneticAnalysis(coupleAnalysisMapList, traitName, genomePairIdentifier, secondGenomePairExists)
|
|
if (err != nil){
|
|
setErrorEncounteredPage(window, err, previousPage)
|
|
return
|
|
}
|
|
|
|
numberOfRulesTestedString := helpers.ConvertIntToString(numberOfRulesTested)
|
|
|
|
traitRulesMap, err := traits.GetTraitRulesMap(traitName)
|
|
if (err != nil){
|
|
setErrorEncounteredPage(window, err, previousPage)
|
|
return
|
|
}
|
|
|
|
totalNumberOfRules := len(traitRulesMap)
|
|
totalNumberOfRulesString := helpers.ConvertIntToString(totalNumberOfRules)
|
|
|
|
rulesTestedLabel := widget.NewLabel("Rules Tested:")
|
|
rulesTestedText := getBoldLabel(numberOfRulesTestedString + "/" + totalNumberOfRulesString)
|
|
rulesTestedHelpButton := widget.NewButtonWithIcon("", theme.QuestionIcon(), func(){
|
|
setOffspringTraitNumberOfRulesTestedExplainerPage(window, currentPage)
|
|
})
|
|
|
|
rulesTestedRow := container.NewHBox(layout.NewSpacer(), rulesTestedLabel, rulesTestedText, rulesTestedHelpButton, layout.NewSpacer())
|
|
|
|
getRulesGrid := func()(*fyne.Container, error){
|
|
|
|
emptyLabelA := widget.NewLabel("")
|
|
ruleIdentifierLabel := getItalicLabelCentered("Rule Identifier")
|
|
|
|
emptyLabelB := widget.NewLabel("")
|
|
ruleEffectsLabel := getItalicLabelCentered("Rule Effects")
|
|
|
|
offspringProbabilityOfLabel := getItalicLabelCentered("Offspring Probability Of")
|
|
passingRuleLabel := getItalicLabelCentered("Passing Rule")
|
|
|
|
emptyLabelC := widget.NewLabel("")
|
|
emptyLabelD := widget.NewLabel("")
|
|
|
|
ruleIdentifierColumn := container.NewVBox(emptyLabelA, ruleIdentifierLabel, widget.NewSeparator())
|
|
ruleEffectsColumn := container.NewVBox(emptyLabelB, ruleEffectsLabel, widget.NewSeparator())
|
|
offspringProbabilityOfPassingRuleColumn := container.NewVBox(offspringProbabilityOfLabel, passingRuleLabel, widget.NewSeparator())
|
|
ruleInfoButtonsColumn := container.NewVBox(emptyLabelC, emptyLabelD, widget.NewSeparator())
|
|
|
|
addRuleRow := func(ruleIdentifier string)error{
|
|
|
|
ruleIdentifierLabel := getBoldLabelCentered(ruleIdentifier)
|
|
|
|
offspringRuleProbabilityKnown, _, offspringProbabilityOfPassingRuleFormatted, err := readGeneticAnalysis.GetOffspringTraitRuleInfoFromGeneticAnalysis(coupleAnalysisMapList, traitName, ruleIdentifier, genomePairIdentifier)
|
|
if (err != nil) { return err }
|
|
|
|
viewRuleDetailsButton := widget.NewButtonWithIcon("", theme.VisibilityIcon(), func(){
|
|
setViewCoupleGeneticAnalysisTraitRuleDetailsPage(window, personAName, personBName, personAAnalysisMapList, personBAnalysisMapList, coupleAnalysisMapList, traitName, ruleIdentifier, currentPage)
|
|
})
|
|
|
|
getProbabilityOfPassingRuleText := func()string{
|
|
if (offspringRuleProbabilityKnown == false){
|
|
|
|
result := translate("Unknown")
|
|
return result
|
|
}
|
|
return offspringProbabilityOfPassingRuleFormatted
|
|
}
|
|
|
|
probabilityOfPassingRuleText := getProbabilityOfPassingRuleText()
|
|
probabilityOfPassingRuleTextLabel := getBoldLabelCentered(probabilityOfPassingRuleText)
|
|
|
|
// We add all of the columns except for the rule effects column
|
|
// We do this because the rule effects column may be multiple rows tall
|
|
|
|
ruleIdentifierColumn.Add(ruleIdentifierLabel)
|
|
offspringProbabilityOfPassingRuleColumn.Add(probabilityOfPassingRuleTextLabel)
|
|
ruleInfoButtonsColumn.Add(viewRuleDetailsButton)
|
|
|
|
traitRuleObject, exists := traitRulesMap[ruleIdentifier]
|
|
if (exists == false){
|
|
return errors.New("Trait rule not found after being found already: " + ruleIdentifier)
|
|
}
|
|
|
|
ruleOutcomePointsMap := traitRuleObject.OutcomePointsMap
|
|
|
|
outcomeNamesList := helpers.GetListOfMapKeys(ruleOutcomePointsMap)
|
|
|
|
// We have to sort the outcome names so they always show up in the same order
|
|
helpers.SortStringListToUnicodeOrder(outcomeNamesList)
|
|
|
|
for index, outcomeName := range outcomeNamesList{
|
|
|
|
outcomeChange, exists := ruleOutcomePointsMap[outcomeName]
|
|
if (exists == false){
|
|
return errors.New("OutcomeName not found in ruleOutcomePointsMap after being found already: " + outcomeName)
|
|
}
|
|
|
|
getOutcomeEffectString := func()string{
|
|
|
|
outcomeChangeString := helpers.ConvertIntToString(outcomeChange)
|
|
|
|
if (outcomeChange < 0){
|
|
return outcomeChangeString
|
|
}
|
|
outcomeEffect := "+" + outcomeChangeString
|
|
return outcomeEffect
|
|
}
|
|
|
|
outcomeEffect := getOutcomeEffectString()
|
|
|
|
outcomeRow := getBoldLabelCentered(outcomeName + ": " + outcomeEffect)
|
|
ruleEffectsColumn.Add(outcomeRow)
|
|
|
|
if (index > 0){
|
|
|
|
emptyLabelA := widget.NewLabel("")
|
|
emptyLabelB := widget.NewLabel("")
|
|
emptyLabelC := widget.NewLabel("")
|
|
|
|
ruleIdentifierColumn.Add(emptyLabelA)
|
|
offspringProbabilityOfPassingRuleColumn.Add(emptyLabelB)
|
|
ruleInfoButtonsColumn.Add(emptyLabelC)
|
|
}
|
|
}
|
|
|
|
ruleIdentifierColumn.Add(widget.NewSeparator())
|
|
ruleEffectsColumn.Add(widget.NewSeparator())
|
|
offspringProbabilityOfPassingRuleColumn.Add(widget.NewSeparator())
|
|
ruleInfoButtonsColumn.Add(widget.NewSeparator())
|
|
|
|
return nil
|
|
}
|
|
|
|
rulesWithKnownProbabilityList := make([]string, 0)
|
|
rulesWithUnknownProbabilityList := make([]string, 0)
|
|
|
|
for ruleIdentifier, _ := range traitRulesMap{
|
|
|
|
offspringRuleProbabilityKnown, _, _, err := readGeneticAnalysis.GetOffspringTraitRuleInfoFromGeneticAnalysis(coupleAnalysisMapList, traitName, ruleIdentifier, genomePairIdentifier)
|
|
if (err != nil) { return nil, err }
|
|
if (offspringRuleProbabilityKnown == true){
|
|
rulesWithKnownProbabilityList = append(rulesWithKnownProbabilityList, ruleIdentifier)
|
|
} else {
|
|
rulesWithUnknownProbabilityList = append(rulesWithUnknownProbabilityList, ruleIdentifier)
|
|
}
|
|
}
|
|
|
|
// Now we sort rules so they show up in the same order each time
|
|
|
|
helpers.SortStringListToUnicodeOrder(rulesWithKnownProbabilityList)
|
|
helpers.SortStringListToUnicodeOrder(rulesWithUnknownProbabilityList)
|
|
|
|
for _, ruleIdentifier := range rulesWithKnownProbabilityList{
|
|
|
|
err = addRuleRow(ruleIdentifier)
|
|
if (err != nil) { return nil, err }
|
|
}
|
|
|
|
for _, ruleIdentifier := range rulesWithUnknownProbabilityList{
|
|
|
|
err = addRuleRow(ruleIdentifier)
|
|
if (err != nil) { return nil, err }
|
|
}
|
|
|
|
ruleEffectsHelpButton := widget.NewButtonWithIcon("", theme.QuestionIcon(), func(){
|
|
setTraitRuleOutcomeEffectsExplainerPage(window, currentPage)
|
|
})
|
|
ruleEffectsColumn.Add(ruleEffectsHelpButton)
|
|
|
|
offspringProbabilityOfPassingRuleHelpButton := widget.NewButtonWithIcon("", theme.QuestionIcon(), func(){
|
|
setOffspringProbabilityOfPassingTraitRuleExplainerPage(window, currentPage)
|
|
})
|
|
offspringProbabilityOfPassingRuleColumn.Add(offspringProbabilityOfPassingRuleHelpButton)
|
|
|
|
rulesGrid := container.NewHBox(layout.NewSpacer(), ruleIdentifierColumn, ruleEffectsColumn, offspringProbabilityOfPassingRuleColumn, ruleInfoButtonsColumn, layout.NewSpacer())
|
|
|
|
return rulesGrid, nil
|
|
}
|
|
|
|
rulesGrid, err := getRulesGrid()
|
|
if (err != nil){
|
|
setErrorEncounteredPage(window, err, previousPage)
|
|
return
|
|
}
|
|
|
|
page := container.NewVBox(title, backButton, widget.NewSeparator(), description1Row, widget.NewSeparator(), genomePairRow, widget.NewSeparator(), rulesTestedRow, widget.NewSeparator(), rulesGrid)
|
|
|
|
setPageContent(page, window)
|
|
}
|
|
|
|
|
|
|
|
// This function implements a page to view the details of a specific rule from a genetic analysis
|
|
// It will show the rule details for all of the couple's genome pairs
|
|
func setViewCoupleGeneticAnalysisTraitRuleDetailsPage(window fyne.Window, personAName string, personBName string, personAAnalysisMapList []map[string]string, personBAnalysisMapList []map[string]string, coupleAnalysisMapList []map[string]string, traitName string, ruleIdentifier string, previousPage func()){
|
|
|
|
currentPage := func(){setViewCoupleGeneticAnalysisTraitRuleDetailsPage(window, personAName, personBName, personAAnalysisMapList, personBAnalysisMapList, coupleAnalysisMapList, traitName, ruleIdentifier, previousPage)}
|
|
|
|
title := getPageTitleCentered("Trait Rule Details - " + traitName)
|
|
|
|
backButton := getBackButtonCentered(previousPage)
|
|
|
|
description := getLabelCentered("Below is the trait rule analysis for the couple.")
|
|
|
|
ruleIdentifierLabel := widget.NewLabel("Rule Identifier:")
|
|
ruleIdentifierText := getBoldLabel(ruleIdentifier)
|
|
ruleInfoButton := widget.NewButtonWithIcon("", theme.InfoIcon(), func(){
|
|
setViewTraitRuleDetailsPage(window, traitName, ruleIdentifier, currentPage)
|
|
})
|
|
ruleIdentifierRow := container.NewHBox(layout.NewSpacer(), ruleIdentifierLabel, ruleIdentifierText, ruleInfoButton, layout.NewSpacer())
|
|
|
|
getGenomePairsRuleInfoGrid := func()(*fyne.Container, error){
|
|
|
|
emptyLabelA := widget.NewLabel("")
|
|
emptyLabelB := widget.NewLabel("")
|
|
|
|
emptyLabelC := widget.NewLabel("")
|
|
genomePairLabel := getItalicLabelCentered("Genome Pair")
|
|
|
|
offspringProbabilityOfLabel := getItalicLabelCentered("Offspring Probability Of")
|
|
passingRuleLabel := getItalicLabelCentered("Passing Rule")
|
|
|
|
viewGenomePairInfoButtonsColumn := container.NewVBox(emptyLabelA, emptyLabelB, widget.NewSeparator())
|
|
genomePairNameColumn := container.NewVBox(emptyLabelC, genomePairLabel, widget.NewSeparator())
|
|
offspringProbabilityOfPassingRuleColumn := container.NewVBox(offspringProbabilityOfLabel, passingRuleLabel, widget.NewSeparator())
|
|
|
|
addGenomePairRow := func(genomePairName string, genomePairIdentifier string)error{
|
|
|
|
offspringRuleProbabilityKnown, _, offspringProbabilityOfPassingRuleFormatted, err := readGeneticAnalysis.GetOffspringTraitRuleInfoFromGeneticAnalysis(coupleAnalysisMapList, traitName, ruleIdentifier, genomePairIdentifier)
|
|
if (err != nil) { return err }
|
|
|
|
getOffspringProbabilityOfPassingRuleText := func()string{
|
|
|
|
if (offspringRuleProbabilityKnown == false){
|
|
result := translate("Unknown")
|
|
return result
|
|
}
|
|
|
|
return offspringProbabilityOfPassingRuleFormatted
|
|
}
|
|
|
|
offspringProbabilityOfPassingRuleText := getOffspringProbabilityOfPassingRuleText()
|
|
|
|
viewGenomePairInfoButton := widget.NewButtonWithIcon("", theme.InfoIcon(), func(){
|
|
setViewCoupleGeneticAnalysisTraitGenomePairDetailsPage(window, personAName, personBName, personAAnalysisMapList, personBAnalysisMapList, coupleAnalysisMapList, traitName, genomePairIdentifier, genomePairName, currentPage)
|
|
})
|
|
|
|
genomePairNameLabel := getBoldLabelCentered(genomePairName)
|
|
|
|
offspringProbabilityOfPassingRuleLabel := getBoldLabelCentered(offspringProbabilityOfPassingRuleText)
|
|
|
|
viewGenomePairInfoButtonsColumn.Add(viewGenomePairInfoButton)
|
|
genomePairNameColumn.Add(genomePairNameLabel)
|
|
offspringProbabilityOfPassingRuleColumn.Add(offspringProbabilityOfPassingRuleLabel)
|
|
|
|
viewGenomePairInfoButtonsColumn.Add(widget.NewSeparator())
|
|
genomePairNameColumn.Add(widget.NewSeparator())
|
|
offspringProbabilityOfPassingRuleColumn.Add(widget.NewSeparator())
|
|
|
|
return nil
|
|
}
|
|
|
|
pair1PersonAGenomeIdentifier, pair1PersonBGenomeIdentifier, secondGenomePairExists, pair2PersonAGenomeIdentifier, pair2PersonBGenomeIdentifier, _, _, _, _, _, _, err := readGeneticAnalysis.GetMetadataFromCoupleGeneticAnalysis(coupleAnalysisMapList)
|
|
if (err != nil){ return nil, err }
|
|
|
|
genomePair1Identifier := pair1PersonAGenomeIdentifier + "+" + pair1PersonBGenomeIdentifier
|
|
|
|
err = addGenomePairRow("Pair 1", genomePair1Identifier)
|
|
if (err != nil) { return nil, err }
|
|
|
|
if (secondGenomePairExists == true){
|
|
|
|
genomePair2Identifier := pair2PersonAGenomeIdentifier + "+" + pair2PersonBGenomeIdentifier
|
|
|
|
err := addGenomePairRow("Pair 2", genomePair2Identifier)
|
|
if (err != nil) { return nil, err }
|
|
}
|
|
|
|
genomesContainer := container.NewHBox(layout.NewSpacer(), viewGenomePairInfoButtonsColumn, genomePairNameColumn, offspringProbabilityOfPassingRuleColumn, layout.NewSpacer())
|
|
|
|
return genomesContainer, nil
|
|
}
|
|
|
|
genomePairsRuleInfoGrid, err := getGenomePairsRuleInfoGrid()
|
|
if (err != nil){
|
|
setErrorEncounteredPage(window, err, previousPage)
|
|
return
|
|
}
|
|
|
|
page := container.NewVBox(title, backButton, widget.NewSeparator(), description, widget.NewSeparator(), ruleIdentifierRow, widget.NewSeparator(), genomePairsRuleInfoGrid)
|
|
|
|
setPageContent(page, window)
|
|
}
|
|
|
|
|
|
|
|
|