Main module controlling displaying segmentations image and data

In order to properly close displayer we need to : remove buffers that wer use remove shaders remove all textures unsubscibe all of the subscriptions to the mainActor finalize main actor and reinstantiate it close GLFW window

coordinating displaying - sets needed constants that are storeds in forDisplayConstants; and configures interactions from GLFW events listOfTextSpecs - holds required data needed to initialize textures keeps also references to needed ..Uniforms etc. windowWidth::Int,windowHeight::Int - GLFW window dimensions fractionOfMainIm - how much of width should be taken by the main image heightToWithRatio - needed for proper display of main texture - so it would not be stretched ...

is used to pass into the actor data that will be used for scrolling onScrollData - struct holding between others list of tuples where first is the name of the texture that we provided and second is associated data (3 dimensional array of appropriate type)

Preparing ForWordsDispStruct that will be needed for proper displaying of texts numberOfActiveTextUnits - number of textures already used - so we we will know what is still free fragmentshaderwords - reference to fragment shader used to display text vbowords - vertex buffer object used to display words shaderprogram_words - shader program associated with displaying text widthh, heightt - size of the texture - the bigger the higher resolution, but higher computation cost

return prepared for displayStruct

is using the actor that is instantiated in this module and connects it to GLFW context by invoking appropriate registering functions and passing to it to the main Actor controlling input

enables updating just a single slice that is displayed - do not change what will happen after scrolling one need to pass data to actor in listOfDataAndImageNames - struct holding tuples where first entry in tuple is name of texture given in the setup and second is 2 dimensional aray of appropriate type with image data sliceNumber - the number to which we set slice in order to later start scrolling the scroll data from this point

add data needed for proper calculations of mouse, verticies positions ... etc

adding the data about 3 dimensional arrays that will be source of data used for scrolling behaviour onScroll Data - list of tuples where first is the name of the texture that we provided and second is associated data (3 dimensional array of appropriate type)

adding the data into about openGL and GLFW context to enable proper display of main image and masks

adding the data needed for text display; also activates appropriate quad for the display it also configures texture that is build for text display

sets value we are setting to the active mask vie mause interaction, in case mask is modifiable

when GLFW context is ready we need to use this function in order to register GLFW events to Rocket actor - we use subscription for this actor - Roctet actor that holds objects needed for display like window etc... return list of subscriptions so if we will need it we can unsubscribe

enables updating just a single slice that is displayed - do not change what will happen after scrolling one need to pass data to actor in struct that holds tuple where first entry is -vector of tuples whee first entry in tuple is name of texture given in the setup and second is 2 dimensional aray of appropriate type with image data

• Int - second is Int64 - that is marking the screen number to which we wan to set the actor state

given number from keyboard input it return array With texture that holds the texture specification we are looking for listOfTextSpecifications - list with all registered Texture specifications numb - string that may represent number - if it does not function will return empty option return Option - either Texture specification or empty Option

Given string it parser it to given object on the basis of with and multiple dispatch futher actions will be done it checks each character weather is numeric - gets substring of all numeric characters and parses it into integer listOfTextSpecifications - list with all registered Texture specifications return option of diffrent type depending on input

Given keyInfo struct wit information about pressed keys it can process them to make some actions - generally activating keyboard shortcuts shift + number - make mask associated with given number visible ctrl + number - make mask associated with given number invisible alt + number - make mask associated with given number active for mouse interaction tab + number - sets the number that will be used as an input to masks modified by mouse shift + numberA + "m" +numberB - display diffrence between masks associated with numberA and numberB - also it makes automaticall mask A and B invisible ctrl + numberA + "m" +numberB - stops displaying diffrence between masks associated with numberA and numberB - also it makes automaticall mask A and B visible space + 1 or 2 or 3 - change the plane of view (transverse, coronal, sagittal) ctrl + z - undo last action tab +/- increase or decrease stroke width F1, F2 ... - switch between defined window display characteristics - like min shown white and mx shown black ...

registering functions to the GLFW window - GLFW window with Visualization stopListening - atomic boolean enabling unlocking GLFW context

return true in case the combination of keys should invoke some action

will "tell" what functions should be invoked in order to process keyboard input

given pressed keys lik 1-9 and all letters resulting key is encoded as string and will be passed here handler object responsible for capturing action str - name of key lik 1,5 f,.j ... but not ctrl shift etc action - for example key press or release scancode - if key do not have short name like ctrl ... it has scancode

module code adapted from https://discourse.julialang.org/t/custom-subject-in-rocket-jl-for-mouse-events-from-glfw/65133/3 it is design to help processing data from -GLFW.SetCursorPosCallback(window, (, x, y) -> println("cursor: x, y")) and for example : cursor: 29.0, 469.0 types Float64 Float64 -GLFW.SetMouseButtonCallback(window, (, button, action, mods) -> println("button action")) for example types MOUSEBUTTON1 PRESS GLFW.MouseButton GLFW.Action The main function is to mark the interaction of the mouse to be saved in appropriate mask and be rendered onto the screen so we modify the data that is the basis of the mouse interaction mask and we pass the data on so appropriate part of the texture would be modified to be displayed on screen

adding the width to the stroke so we will be able to controll how thicly we are painting ...

helper function for translateMouseToTexture

helper function for translateMouseToTexture

we use mouse coordinate to modify the texture that is currently active for modifications - we take information about texture currently active for modifications from variables stored in actor from texture specification we take also its id and its properties ...

we pass coordinate of cursor only when isLeftButtonDown is true and we make it true if left button is presed down - we make it true if the left button is pressed over image and false if mouse get out of the window or we get information about button release imageWidth adn imageHeight are the dimensions of textures that we use to display

given list of cartesian coordinates and some window/ image characteristics - it translates mouse positions to cartesian coordinates of the texture strokeWidth - the property connected to the texture marking how thick should be the brush mouseCoords - list of coordinates of mouse positions while left button remains pressed calcDims - set of values usefull for calculating mouse position return vector of translated cartesian coordinates

we define how handler should act on the subject - observable so it will pass event onto subject - here we have 2 events that we want to be ready for - mouse button press example of possible inputs that we would be intrested in for example : cursor: 29.0, 469.0 types Float64 Float64 for example MOUSEBUTTON1 PRESS types GLFW.MouseButton GLFW.Action MOUSEBUTTON1 RELEASE types GLFW.MouseButton GLFW.Action We get two overloads so we will be able to respond with single handler to both mouse click and mouse position Enum GLFW.Action: RELEASE = 0 PRESS = 1 REPEAT = 2 Enum GLFW.MouseButton: MOUSEBUTTON1 = 0 MOUSEBUTTON2 = 1

experiments show that max x,y in window is both 600 if window width and height is 600 so in order to specify weather we are over aour quad we need to know how big is primary quad - defaoul it is occupying 100% of y axis and first left 80% of x axis hence we can calculate max height to equal the height of the window

module that holds functions needed to react to scrolling Generally first we need to pass the GLFW callback to the Rocket obeservable code adapted from https://discourse.julialang.org/t/custom-subject-in-rocket-jl-for-mouse-events-from-glfw/65133/3

in case of the scroll p true will be send in case of down - false in response to it it sets new screen int variable and changes displayed screen toBeSavedForBack - just marks weather we wat to save the info how to undo latest action

• false if we invoke it from undoing

uploading data to given texture; of given types associated returns subscription in order to enable unsubscribing in the end window - GLFW window stopListening - atomic boolean able to stop the event listening cycle return scrollback - that holds boolean subject (observable) to which we can react by subscribing appropriate actor

configuting Rocket on Subscribe so we get custom handler of input as we see we still need to define actor

we define how handler should act on the subject - observable so it will pass event onto subject If we will scroll fast number will change much and we will skip some slices

On the basis of information from listOfTexturesToCreate it creates specialized shader program

preparing all for displaying the images and responding to mouse and keyboard input listOfTexturesToCreate- list of texture specifications needed to for example create optimal shader calcDimsStruct - holds important data about verticies, textures dimensions etc.

stores functions needed to create bind and update OpenGl textues

activating textures that were already initialized in order to be able to use them with diffrent shader program shader_program- regference to OpenGL program so we will be able to activate textures listOfTextSpecs - list of TextureSpec structs that holds data needed to bind textures to shader program (Hovewer this new shader program have to keep the same ..Uniforms) return unmodified textures

Given vector of SimpleLineTextStructs it will return matrix of data that will be used to display text lines - data about text to be displayed calcDimStruct - struct holding important data about size of textures etc. wordsDispObj - object wit needed constants to display text

on the basis of the type supplied in texture characteristic it supplies given set of ..Uniforms to it It would also assign proper openGl types to given julia data type, and pass data from texture specification to opengl context textSpecs - list of texture specificaton that we want to enrich by adding information about ..Uniforms return list of texture specifications enriched by information about ..Uniforms

creating texture that is storing values like integer, uint, float values that are representing main image or mask data and which will be used by a shader to draw appropriate colors juliaDataType- data type defined as a Julia datatype of data we are dealing with width,height - dimensions of the texture that we need GL_RType,OpGlType - Open Gl types needed to properly specify the texture they need to be compatible with juliaDataType

associates GL_TEXTURE UInt32 to given index

initializing textures - so we basically execute specification for configuration and bind all to OpenGL context listOfTextSpecs - list of TextureSpec structs that holds data needed to calcDimStruct - struct holding necessery data about taxture dimensions, quad propertiess etc.

On the basis of the type associated to texture we set proper open Gl types associated based on https://www.khronos.org/registry/OpenGL-Refpages/gl4/html/glTexImage2D.xhtml and https://www.khronos.org/opengl/wiki/OpenGL_Type

helper for assign..UniformsToMasks On the basis of the name of the Texture it will assign the informs referencs to it

• ..Uniforms for main image will be set separately

coordinating updating all of the images, masks... singleSliceDat - holds data we want to use for update forDisplayObjects - stores all needed constants that holds reference to GLFW and OpenGL

uploading data to given texture; of given types associated - specified in TextureSpec if we want to update only part of the texture we need to specify offset and size of texture we use Just for reference openGL function definition void glTextureSubImage2D( GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const void *pixels);

Module controlling displaying of the text associated with the segmentation

• either text releted to all slices or just a single one currently displayed or both

In order to be able to display texture with text we need to activate main shader program and vbo shaderprogram- reference to shader program fragmentshader_words - reference to shader associated with text displaying calcDim - holds necessery constants holding for example window dimensions, texture sizes etc.

First We need to bind fragment shader created to deal with text and supply the vertex shader with data for quad where this text needs to be displayed shader_program- reference to shader program this function is intended to be invoked only once

Creates and initialize texture that will be used for displaying text !!!! important we need to first bind shader program for text display before we will invoke this function numberOfActiveTextUnits - number of textures already used - so we we will know what is still free widthh, heightt - size of the texture - the bigger the higher resolution, but higher computation cost actTextrureNumb -proper OpenGL active texture return fully initialized texture; also it assigne texture to appropriate sampler

we need to check wether scrolling dat contains some text that can be used for this particular slice display if not we will return only mainTextToDisp

Finally in order to enable later proper display of the images we need to reactivate main quad and shaders shaderprogram- reference to shader program fragmentshader_main- reference to shader associated with main images

Given single SimpleLineTextStruct it will return matrix of data that will be used by addTextToTexture function to display text texLine - source od data textureWidth - available width for a line fontFace - font we use

utility function that enables creating list of text line structs from list of strings

managing uniform values - global values in shaders

controlls contribution of given mask to the overall image - maximum value is 1 minimum 0 if we have 3 masks and all control contribution is set to 1 and all are visible their corresponding influence to pixel color is 33% if plus is pressed it will increse contribution by 0.1 if minus is pressed it will decrease contribution by 0.1 it also modifies given TextureSpec change - how should the texture spec be modified

sets minimum and maximum value for display - in case of continuus colors it will clamp values - so all above max will be equaled to max ; and min if smallert than min in case of main CT mask - it will controll min shown white and max shown black in case of maks with single color associated we will step data so if data is outside the rande it will return 0 - so will not affect display

    getuniform(program, name) -> GLint

Gets the location of the uniform variable identified by name.

function cotrolling the window for displaying CT scan - min white and max maxshownblack uniformsStore - instantiated object holding references to uniforms controlling displayed window

sets color of the mask

sets visibility of the texture

    uniform!(location, values...) -> Nothing

Set the uniform vec variable at location.

Examples

myuniform = getuniform(program, "someUniform")
# set float vec3
uniform!(myuniform, 1.0, 1.0, 0.5)
# set float vec4
uniform!(myuniform, Cfloat[1, 2, 3, 4])
# set a 4x4 matrix
uniform!(myuniform, rand(Cfloat, 4, 4))

creating fragment Shader so controlling colors and textures gslString so version of GSLS we are using currently

creating VertexShader so controlling structures like verticies, quads gslString so version of GSLS we are using currently

generetes verticies for quad used for displaying text

creating fragment Shader so controlling colors and textures gslString so version of GSLS we are using currently

creating VertexShader so controlling structures like verticies, quads gslString so version of GSLS we are using currently

loading the shader from file- so we have better experience writing shader in separate file (can be used if we do not use Custom frag shader)

As most functions will deal with just addind the quad to the screen and swapping buffers

functions that will enable creation of long String that will be the code for custom fragment shader that will be suited for defined textures

Adding ..Uniforms resopnsible for colors associated with given mask

managing main texture and on the basis of the type we will initialize diffrent variables mainTexture - specification of a texture related to main image

Adding string necessary for managing ..Uniforms of masks textures

setting string representing sampler depending on type

giving variable name associated with given type

Add ..Uniforms necessary for operation of mask subtraction and for proper display of nuclear medicine masks

giving string representing main function defining how windowing of main image should be performed

on the basis of texture type gives proper function controlling color of the mask

We will in couple steps create code for fragment shader that will be based on the texture definitions we gave listOfTexturesToCreate - list of textures on the basis of which we will create custom fragment shader code maskToSubtrastFrom,maskWeAreSubtracting - texture specifications used in order to generate code needed to diplay diffrence between those two masks - every time we want diffrent diffrence we will need to recreate shader invoking this function

We divide textures into main image texture and the rest listOfTexturesToCreate - list of textures on the basis of which we will create custom fragment shader code returns tuple where fist entr is the main image texture specification and second is rest of textures

used in order to enable subtracting one mask from the other - hence displaying pixels where value of mask a is present but mask b not (order is important) automatically both masks will be set to be invisible and only the diffrence displayed

In order to provide maximum performance and avoid branching inside shader multiple shader programs will be attached and one choosed that will use diffrence needed maskToSubtrastFrom,maskWeAreSubtracting - specifications o textures we are operating on

Enable displaying for example nuclear medicine data by applying smoothly changing colors to floating point data 1)in confguration phase we need to have minimum, maximum and range of possible values associated with nuclear mask 2)as uniform we would need to have set of vec4's - those will be used to display colors 3)colors will be set with algorithm presented below a)range will be divided into sections (value ranges) wich numbers will equal length of colors vector - 1 b)in each section the output color will be mix of 2 colors one associated with this section and with next one - contribution of the color associated with given section will vary from 100% at the begining of the section to 0% in the end where 100% of color will be associated with color of next section

some initial constants that are the same irrespective of textures

controlling main function - basically we need to return proper FragColor which represents pixel color in given spot we generete separately r,g and b values by adding contributions from all textures

Giving value from texture f the texture is set to be visible otherwise 0

It stores set of functions that need to be composed in order to prepare GLFW window and display verticies needed for texture display

it will generally be invoked on GLFW.PollEvents() in event loop and now depending on what will be pressed or clicked it will lead to diffrent actions

data is loaded into a buffer which passes it into thw GPU for futher processing - here the data is just passing the positions of verticies GLSTREAMDRAW the data is set only once and used by the GPU at most a few times. GLSTATICDRAW the data is set only once and used many times. GLDYNAMICDRAW the data is changed a lot and used many times.

Similar to the VBO we bind the EBO and copy the indices into the buffer with glBufferData.

vertex buffer keeping things simpler

how data should be read from data buffer

showing how openGL should read data from buffer in GPU in case of code like below it would mean:

first parameter specifies which vertex attribute we want to configure Remember that we specified the location of the position vertex attribute in the vertex shader next argument specifies the size of the vertex attribute. The vertex attribute is a vec2 so it is composed of 2 values. The third argument specifies the type of the data which is GLFLOAT next argument specifies if we want the data to be normalized. If we’re inputting integer data types like int, byte and we’ve set this to GLTRUE The fifth argument is known as the stride and tells us the space between consecutive vertex attributes. Since the next set of position data is located exactly 2 times the size of a float we could’ve also specified the stride as 0 to let OpenGL determine the stride he last parameter is of type void* and thus requires that weird cast. This is the offset of where the position data begins in the buffer.

glVertexAttribPointer positionAttribute, 2, GLFLOAT, false, 0, CNULL

The position data is stored as 32-bit  so 4 byte floating point values. 
Each position is composed of 2 of those values.

modified from ModernGL.jl github page and GLFW page stores primary

utilities for dealing data structs like FullScrollableDat or SingleSliceDat

modifies given slice in given coordinates of given data - queried by name data - full data we work on and modify coords - coordinates in a plane of chosen slice to modify (so list of x and y coords) value - value to set for given points return reference to modified slice

given Vector of TextureSpecs it creates dictionary where keys are associated names and values are indicies where they are found in a list

Actor that is able to store a state to keep needed data for proper display

currentDisplayedSlice::Int=1 # stores information what slice number we are currently displaying mainForDisplayObjects:: forDisplayObjects=forDisplayObjects() # stores objects needed to display using OpenGL and GLFW onScrollData::FullScrollableDat = FullScrollableDat() textureToModifyVec::Vector{TextureSpec}=[] # texture that we want currently to modify - if list is empty it means that we do not intend to modify any texture isSliceChanged::Bool= false # set to true when slice is changed set to false when we start interacting with this slice - thanks to this we know that when we start drawing on one slice and change the slice the line would star a new on new slice textDispObj::ForWordsDispStruct =ForWordsDispStruct()# set of objects and constants needed for text diplay currentlyDispDat::SingleSliceDat =SingleSliceDat() # holds the data displayed or in case of scrollable data view for accessing it calcDimsStruct::CalcDimsStruct=CalcDimsStruct() #data for calculations of necessary constants needed to calculate window size , mouse position ... valueForMasToSet::valueForMasToSetStruct=valueForMasToSetStruct() # value that will be used to set pixels where we would interact with mouse lastRecordedMousePosition::CartesianIndex{3} = CartesianIndex(1,1,1) # last position of the mouse related to right click - usefull to know onto which slice to change when dimensions of scroll change forUndoVector::AbstractArray=[] # holds lambda functions that when invoked will undo last operations maxLengthOfForUndoVector::Int64 = 10 # number controls how many step at maximum we can get back isBusy::Base.Threads.Atomic{Bool}= Threads.Atomic{Bool}(0) # used to indicate by some functions that actor is busy and some interactions should be ceased

Holding necessery data to display text - like font related

Object that enables managing input from keyboard - it stores the information also about needed keys wheather they are kept pressed examples of keyboard input (raw GLFW input we process below) action RELEASE GLFW.Action key s StringPRESS key s String action PRESS GLFW.Action key s StringRELEASE key s String action RELEASE GLFW.Action

Holding necessery data to controll keyboard shortcuts

isCtrlPressed::Bool = false# left - scancode 37 right 105 - Int32 isShiftPressed::Bool = false # left - scancode 50 right 62- Int32 isAltPressed::Bool= false# left - scancode 64 right 108- Int32 isEnterPressed::Bool= false# scancode 36 isTAbPressed::Bool= false# isSpacePressed::Bool= false# isF1Pressed::Bool= false isF2Pressed::Bool= false isF3Pressed::Bool= false

lastKeysPressed::Vector{String}=[] # last pressed keys - it listenes to keys only if ctrl/shift or alt is pressed- it clears when we release those case or when we press enter #informations about what triggered sending this particular struct to the actor mostRecentScanCode ::GLFW.Key=GLFW.KEYKP4 mostRecentKeyName ::String="" mostRecentAction ::GLFW.Action= GLFW.RELEASE

Holding references to ..Uniforms used to controll main image

data needed for definition of mask - data that will be displayed over main image this struct is parametarized by type of 3 dimensional array that will be used to store data

hold reference numbers that will be used to access and modify given uniform value In order to have easy fast access to the values set the most recent values will also be stored inside In order to improve usability we will also save with what data type this mask is associated for example Int, uint, float etc

struct that enables reacting to the input from mouse click and drag the input will be Cartesian index represening (x,y) x and y position of the mouse - will be recorded only if left mouse button is pressed or keep presssed

Holding necessery data to controll mouse interaction

struct that enables reacting to the input from scrolling

Holding the data needed to create and later reference the textures

name::String="" #human readable name by which we can reference texture numb::Int32 =-1 #needed to enable swithing between textures generally convinient when between 0-9; needed only if texture is to be modified by mouse input whichCreated::Int32 =-1 #marks which one this texture was when created - so first in list second ... - needed for convinient accessing ..Uniforms in shaders isMainImage ::Bool = false #true if this texture represents main image isNuclearMask ::Bool = false # used for example in case of nuclear imagiing studies isContinuusMask ::Bool = false # in case of masks if mask is continuus color display we set multiple colors in a vector color::RGB = RGB(0.0,0.0,0.0) #needed in case for the masks in order to establish the range of colors we are intrested in in case of binary mask there is no point to supply more than one color (supply Vector with length = 1) colorSet::Vector{RGB}=[] #set of colors that can be used for mask with continous values strokeWidth::Int32 =Int32(3)#marking how thick should be the line that is left after acting with the mouse ... isEditable::Bool =false #if true we can modify given texture using mouse interaction GLRtype::UInt32 =UInt32(0) #GlRtype - for example GLR8UI or GLR16I OpGlType ::UInt32 =UInt32(0) #open gl type - for example GLUNSIGNEDBYTE or GLSHORT actTextrureNumb ::UInt32 =UInt32(0) #usefull to be able to activate the texture using GLActivetexture - with proper open GL constant associatedActiveNumer ::Int64 =Int64(0) #usefull to be able to activate the texture using GLActivetexture - with proper open GL constant ID::Base.RefValue{UInt32} = Ref(UInt32(0)) #id of Texture isVisible::Bool= true #if false it should be invisible uniforms::TextureUniforms=MaskTextureUniforms()# holds values needed to control ..Uniforms in a shader minAndMaxValue::Vector{T} = []#entry one is minimum possible value for this mask, and second entry is maximum possible value for this mask

hold reference numbers that will be used to access and modify given uniform value in a shader

Defined in order to hold constant objects needed to display images listOfTextSpecifications::Vector{TextureSpec} = [TextureSpec()] window = [] vertexshader::UInt32 =1 fragmentshader::UInt32=1 shader_program::UInt32=1 stopListening::Base.Threads.Atomic{Bool}= Threads.Atomic{Bool}(0)# enables unlocking GLFW context for futher actions vbo::UInt32 =1 #vertex buffer object id ebo::UInt32 =1 #element buffer object id mainImageUniforms::MainImageUniforms = MainImageUniforms()# struct with references to main image TextureIndexes::Dictionary{String, Int64}=Dictionary{String, Int64}() #gives a way of efficient querying by supplying dictionary where key is a name we are intrested in and a key is index where it is located in our array numIndexes::Dictionary{Int32, Int64} =Dictionary{Int32, Int64}() # a way for fast query using assigned numbers gslsStr::String="" # string giving information about used openg gl gsls version windowControlStruct::WindowControlStruct=WindowControlStruct()# holding data usefull to controll display window

structs helping managing and storing data

given Vector of tuples where first is string and second is RawDataToDisp it creates dictionary where keys are those strings - names and values are indicies where they are found

struct holding data usefull to controll mouse interaction with image - so stroke width etc.

struct holding data needed for calculating proper mouse position , getting proper size for the texture depending on image dimensions getting into account proportions of diffrent parts of display usefull stats for proper text display

hold Data that can be send to be displayed with required metadata

stores additional data about full dimensions of scrollable dat - this is necessery for switching slicing plane orientation efficiently

Data that can be displayed and scrolled (so we have multiple slices) struct is mutable becouse in case of the masks data can be changed multiple times and rapidly

hold raw Data that can be send to be displayed

Struct holding line of text with some text metadata

Data for displaying single slice struct is mutable becouse in case of the masks data can be changed multiple times and rapidly

3 dimensional data for displaying single slice struct is mutable becouse in case of the masks data can be changed multiple times and rapidly

2 dimensional ata for displaying single slice struct is mutable becouse in case of the masks data can be changed multiple times and rapidly

struct holding data usefull to controll display window

simple struct that when passed is giving information about what should be current value we are setting to the mask

configuration struct that when passed will marks what kind of metrics we are intrested in

constants associated with image over which we will evaluate segmentations

Struct holding all resulting metrics - if some metric was not calculated its value is just -1

copied from ModernGL github repository

for case when we want to subtract two masks

SUBTRACTING MASKS used in order to enable subtracting one mask from the other - hence displaying pixels where value of mask a is present but mask b not (order is important) automatically both masks will be set to be invisible and only the diffrence displayed

In order to achieve this we need to have all of the samplers references stored in a list

1. we need to set both masks to invisible - it will be done from outside the shader
2. we set also from outside uniform marking visibility of diffrence to true
3. also from outside we need to set which texture to subtract from which we will achieve this by setting maskAtoSubtr and maskBtoSubtr int ..Uniforms those integers will mark which samplers function will use
4. in shader function will be treated as any other mask and will give contribution to output color multiplied by its visibility(0 or 1)
5. inside the function color will be defined as multiplication of two colors of mask A and mask B - colors will be acessed similarly to samplers
6. color will be returned only if value associated with maskA is greater than mask B and proportional to this difffrence

In order to provide maximum performance and avoid branching inside shader multiple shader programs will be attached and one choosed that will use diffrence needed maskToSubtrastFrom,maskWeAreSubtracting - specifications o textures we are operating on

for case when we want to subtract two masks

for case we want to undo subtracting two masks

controls mask visibility responds to keyboard input

processing information from keys - the instance of this function will be chosen on the basis mainly of multiple dispatch

sets visibility and render the result to the screen

functions to controll stroke width , setting which texture is currently active and actions undoing

in case we want to get new number set for manual modifications toBeSavedForBack - just marks weather we wat to save the info how to undo latest action - false if we invoke it from undoing

when tab plus will be pressed it will increase stroke width when tab minus will be pressed it will increase stroke width

In order to enable undoing last action we just invoke last function from list

functions that controll window - so basically treshords for mask display

Based on window struct and key info it will controll which function should be invoked

helper function for setTextureWindow on the basis of given texture spec will give value proportional to the range

sets upper treshold and decrese it

sets upper treshold and Increase it

sets lower treshold and decrese it

sets lower treshold and Increase it

sets mask contribution and decrese it

sets mask contribution and increase it

On the basis of the input WindowControlStruct and keyInfo it makes necessary primary modifications to WindowControlStruct

KEYF1 - will display wide window for bone Int32(1000),Int32(-1000) KEYF2 - will display window for soft tissues Int32(400),Int32(-200) KEYF3 - will display wide window for lung viewing Int32(0),Int32(-1000) KEYF4, KEYF5 - sets minimum (F4) and maximum (KEYF5) value for display (with combination of + and minus signs - to increase or decrease given treshold) - in case of continuus colors it will clamp values - so all above max will be equaled to max ; and min if smallert than min in case of main CT mask - it will controll min shown white and max shown black in case of maks with single color associated we will step data so if data is outside the rande it will return 0 - so will not affect display KEY_F6 - controlls contribution of given mask to the overall image - maximum value is 1 minimum 0 if we have 3 masks and all control contribution is set to 1 and all are visible their corresponding influence to pixel color is 33% if plus is pressed it will increse contribution by 0.1 if minus is pressed it will decrease contribution by 0.1

sets minimum and maximum value for display - in case of continuus colors it will clamp values - so all above max will be equaled to max ; and min if smallert than min in case of main CT mask - it will controll min shown white and max shown black in case of maks with single color associated we will step data so if data is outside the rande it will return 0 - so will not affect display

set main window - min shown white and max shown black on the basis of textur data and windowStruct

controls changing plane for example from transverse to saggital ...