From 60d77225e84e7d0e6965682ce52f58b455c45380 Mon Sep 17 00:00:00 2001 From: sbastiaens <62792658+sbastiaens@users.noreply.github.com> Date: Mon, 22 Nov 2021 15:22:03 -0500 Subject: [PATCH 1/6] New Homer pipeline --- kftools/homer/Homer_Atlas_2.m | 338 ++++++++++++++++++++++++++++++++++ 1 file changed, 338 insertions(+) create mode 100644 kftools/homer/Homer_Atlas_2.m diff --git a/kftools/homer/Homer_Atlas_2.m b/kftools/homer/Homer_Atlas_2.m new file mode 100644 index 0000000..600626c --- /dev/null +++ b/kftools/homer/Homer_Atlas_2.m @@ -0,0 +1,338 @@ +% Pipeline Kernel Homer3 and AtlasViewer + +% NOTE: Beforehand do setpaths in Homer3 folder and add Atlas-viewer to the path. + +%Then go to folder with digpts.txt, probe.SD and your snirf moments file +function [dc,fwmodel] = Homer_Atlas(snirfFileName,dirname_atlas_viewer,currFolder) + +%[fwmodel, probe] = ForwardModel(dirname_atlas_viewer, currFolder); +snirf_data = MeanMoments(snirfFileName); +load('C:\Users\zheng_wang\Downloads\Homer3-master\Homer3-master\Test_John_FT\homerOutput\atlasViewer.mat'); +dc = HomerProcessing(snirf_data, probe); +%SaveData(dc,fwmodel.Adot); +SaveData(dc); +end + + +% 1) Get Mean of the moments + +function res = MeanMoments(snirfFileName) + +snirf = SnirfLoad(snirfFileName); %original file +snirf_cop = snirf; +timeSeries = snirf.data.dataTimeSeries; +measurementList = snirf.data.measurementList; + +snirf_cop.data.dataTimeSeries = timeSeries(:,2:3:length(timeSeries(1,:))); +snirf_cop.data.measurementList = measurementList(2:3:length(measurementList(1,:))); +%SnirfSave('../Test_ft_Renee/test_renee_ft.snirf', snirf_cop); +res = snirf_cop; +end + +% 2) Homer3 processing + +function dc = HomerProcessing(res, probe) +%[pname, fname] = fileparts(filename); +%if isempty(pname) +% pname = pwd; +%end +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% +% Load acquisition file +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% +% Acquired data (See SNIRF spec for list of acquired data parameters) +%acquired = SnirfClass([pname, '/', fname, '.snirf']); + +acquired = res; +% String together user functions to get from acquired data +% to HRF +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% +%data_dnan = acquired; +%tmp = acquired.data.dataTimeSeries; +%tmp(isnan(tmp))= mean(mean(); +%data_dnan.data.dataTimeSeries = tmp; +acquired.data.dataTimeSeries = hmrR_PreprocessIntensity_NAN(res.data); + +dod = hmrR_Intensity2OD(acquired.data); +dod_nan_rm = dod; +dod_nan_rm.dataTimeSeries = hmrR_PreprocessIntensity_NAN(dod); +dod = hmrR_BandpassFilt(dod_nan_rm, 0.01, 0.50); + +dod_nan_rm = dod; +dod_nan_rm.dataTimeSeries = hmrR_PreprocessIntensity_NAN(dod); +dc = hmrR_OD2Conc_zw(dod, acquired.probe, probe, [1,1]); +end + + + +function dc = hmrR_OD2Conc_zw( dod, probe, probe_true, ppf ) + +dc = DataClass().empty(); + +for ii=1:length(dod) + dc(ii) = DataClass(); + + Lambda = probe.GetWls(); + SrcPos_data = probe.GetSrcPos(); + SrcPos = probe_true.srcpos; + DetPos_data = probe.GetDetPos(); + DetPos = probe_true.detpos; + nWav = length(Lambda); + ml = dod(ii).GetMeasList(); + y = dod(ii).GetDataTimeSeries(); + + if length(ppf) < nWav + warning('Length of ppf does not match the number of wavelengths. Falling back to ppf=1 for all wavelengths.'); + ppf = ones(1, nWav); + elseif length(ppf) > nWav + d = length(ppf)-nWav; + ppf(end-d+1:end) = []; + end + + if ~isempty(find(ppf==1)) + ppf = ones(size(ppf)); + end + + nTpts = size(y,1); + + e = GetExtinctions(Lambda); + e = e(:,1:2) / 10; % convert from /cm to /mm + einv = inv( e'*e )*e'; + %size(einv) + + + for idx=1:length(probe_true.ml) + k = 3*(idx-1)+1; + %idx1 = lst(idx); + %idx2 = find( probe.ml(:,4)>1 & probe.ml(:,1)== probe.ml(idx1,1) & ml(:,2)==ml(idx1,2) ); + + rho = norm(SrcPos(probe_true.ml(idx,1),:)-DetPos(probe_true.ml(idx,2),:)); + + idx1 = find(ml(:,4) ==1 & ml(:,1) == probe_true.ml(idx,1) & ml(:,2)== probe_true.ml(idx,2) ); + idx2 = find(ml(:,4) ==2 & ml(:,1) == probe_true.ml(idx,1) & ml(:,2)== probe_true.ml(idx,2) ); + if isempty(idx1) + y_mean = ones(nTpts,2); + y_mean(:,1)=mean(y,2); + y_mean(:,2)=mean(y,2); + if ppf(1)~=1 + + y2(:,k:k+1) = ( einv * (y_mean./(ones(nTpts,1)*rho*ppf))' )'; + else + y2(:,k:k+1) = ( einv * (y_mean./(ones(nTpts,1)))' )'; + end + else + if ppf(1)~=1 + y2(:,k:k+1) = ( einv * (y(:,[idx1(1) idx2(1)'])./(ones(nTpts,1)*rho*ppf))' )'; + else + y2(:,k:k+1) = ( einv * (y(:,[idx1(1) idx2(1)'])./(ones(nTpts,1)))' )'; + end + end + y2(:,k+2) = y2(:,k) + y2(:,k+1); + dc(ii).AddChannelHbO(probe_true.ml(idx,1), probe_true.ml(idx,2)); + dc(ii).AddChannelHbR(probe_true.ml(idx,1), probe_true.ml(idx,2)); + dc(ii).AddChannelHbT(probe_true.ml(idx,1), probe_true.ml(idx,2)); + end + dc(ii).SetDataTimeSeries(y2); + dc(ii).SetTime(dod(ii).GetTime()); +end +end + + + +% 3) AtlasViewer +function [fwmodel, probe] = ForwardModel(dirname_atlas_viewer, currFolder) + +% Registration from Digpoints (+register probe to surface) + +dirnameAtlas = [dirname_atlas_viewer, '/Data/Colin/']; +searchPaths = dirnameAtlas; + +headvol = initHeadvol(); +headsurf = initHeadsurf(); +pialsurf = initPialsurf(); +refpts = initRefpts(); +digpts = initDigpts(); +probe = initProbe(); +fwmodel = initFwmodel(); +labelssurf = initLabelssurf(); +imgrecon = initImgRecon(); + +headvol = getHeadvol(headvol, searchPaths); +headsurf = getHeadsurf(headsurf, searchPaths); +pialsurf = getPialsurf(pialsurf, searchPaths); + +headsurf.pathname = dirnameAtlas; +headvol.pathname = dirnameAtlas; + +refpts = getRefpts(refpts, headsurf.pathname); +labelssurf = getLabelssurf(labelssurf, headsurf.pathname); +fwmodel = getFwmodel(fwmodel, currFolder, pialsurf, headsurf, headvol, probe); +imgrecon = getImgRecon(imgrecon, currFolder, fwmodel, pialsurf, probe); + + + +%pwd = dirnameSubj +digpts = getDigpts(digpts, currFolder, refpts); + +probe = getProbe(probe, currFolder, digpts, headsurf, refpts); + + +% First determine transformation to monte carlo space from volume +% Generate transformation from head volume to digitized points space +[rp_atlas, rp_subj] = findCorrespondingRefpts(refpts, digpts); +headvol.T_2digpts = gen_xform_from_pts(rp_atlas, rp_subj); +headvol.imgOrig = headvol.img; + +% Register headvol to digpts but first check fwmodel if it's volume +% is already registered to digpts. if it is then set the headvol object +% to the fwmodel's headvol and reuse it. +if ~isregisteredFwmodel(fwmodel, headvol) + + [headvol.img, digpts.T_2mc] = ... + xform_apply_vol_smooth(headvol.img, headvol.T_2digpts); + + headvol.T_2mc = digpts.T_2mc * headvol.T_2digpts; + headvol.center = xform_apply(headvol.center, headvol.T_2mc); + headvol.orientation = digpts.orientation; + + % The MC space volume changed invalidating fwmodel meshes and + % vol to surface mesh. We need to recalculate all of this. + + % fwmodel = resetFwmodel(fwmodel, headvol); + % imgrecon = resetImgRecon(imgrecon); + +else + + % Reusing MC space headvol from fwmodel. + headvol = fwmodel.headvol; + + % We know that headvol.T_2mc = digpts.T_2mc * headvol.T_2digpts. + % Here we need to recover digpts.T_2mc. We can do this from + % headvol.T_2mc and headvol.T_2digpts with a little matrix algebra + digpts.T_2mc = headvol.T_2mc / headvol.T_2digpts; + +end + +digpts.refpts.pos = xform_apply(digpts.refpts.pos, digpts.T_2mc); +digpts.pcpos = xform_apply(digpts.pcpos, digpts.T_2mc); +digpts.srcpos = xform_apply(digpts.srcpos, digpts.T_2mc); +digpts.detpos = xform_apply(digpts.detpos, digpts.T_2mc); +digpts.optpos = [digpts.srcpos; digpts.detpos]; +digpts.center = digpts.refpts.center; + +% Copy digitized optodes to probe object +if ~isempty(probe.optpos_reg) + probe.optpos_reg = xform_apply(probe.optpos_reg, digpts.T_2mc * probe.T_2digpts); +else + probe.optpos_reg = xform_apply(probe.optpos, digpts.T_2mc * probe.T_2digpts); +end + +% move head surface to monte carlo space +headsurf.mesh.vertices = xform_apply(headsurf.mesh.vertices, headvol.T_2mc); +headsurf.center = xform_apply(headsurf.center, headvol.T_2mc); +headsurf.centerRotation = xform_apply(headsurf.centerRotation, headvol.T_2mc); + +% move pial surface to monte carlo space +pialsurf.mesh.vertices = xform_apply(pialsurf.mesh.vertices, headvol.T_2mc); +pialsurf.center = xform_apply(pialsurf.center, headvol.T_2mc); + +% move anatomical labels surface to monte carlo space +labelssurf.mesh.vertices = xform_apply(labelssurf.mesh.vertices, headvol.T_2mc); +labelssurf.center = xform_apply(labelssurf.center, headvol.T_2mc); + +% move ref points to monte carlo space +refpts = xform_apply_Refpts(refpts, headvol.T_2mc); + +% The fwmodel meshes are inherited from pial and head surf at init time. Therefore they are +% in original unregistered volume space, not MC space. Therefore we have to transform it to +% MC space. +fwmodel.mesh.vertices = xform_apply(fwmodel.mesh.vertices, headvol.T_2mc); +fwmodel.mesh_scalp.vertices = xform_apply(fwmodel.mesh_scalp.vertices, headvol.T_2mc); +fwmodel.mesh_orig.vertices = xform_apply(fwmodel.mesh_orig.vertices, headvol.T_2mc); +fwmodel.mesh_scalp_orig.vertices = xform_apply(fwmodel.mesh_scalp_orig.vertices, headvol.T_2mc); + +% The imgrecon meshes are inherited from pial surf at init time. Therefore they are +% in original unregistered volume space, not MC space. Therefore we have to transform it to +% MC space. +imgrecon.mesh.vertices = xform_apply(imgrecon.mesh.vertices, headvol.T_2mc); +imgrecon.mesh_orig.vertices = xform_apply(imgrecon.mesh_orig.vertices, headvol.T_2mc); + +% Finish Registration +if ~headsurf.isempty(headsurf) + headobj = headsurf; +else + headobj = headvol; +end + +refpts.eeg_system.selected = '10-5'; +refpts = set_eeg_active_pts(refpts, [], false); +% Finish registration +if isempty(probe.al) + + % Register probe by simply pulling (or pushing) optodes toward surface + % toward (or away from) center of head. + method = 'digpts'; + probe = pullProbeToHeadsurf(probe, headobj); + probe.hOptodesIdx = 1; + +else + + % Register probe using springs based method + if headvol.isempty(headvol) + menu('Error registering probe using spring relaxation. Headvol object is empty','OK'); + return; + end + method = 'springs'; + probe = probeRegisterSpringsMethod(probe, headvol, refpts); + +end + + +% View registered optodes on the head surface +%probe = viewProbe(probe, 'registered'); + +% Draw measurement list and save handle +%probe = findMeasMidPts(probe); + +%fwmodel = updateGuiControls_AfterProbeRegistration(probe, fwmodel, imgrecon, labelssurf); + +%probe.hOptodesIdx = 1; +%probe = setProbeDisplay(probe, headsurf, method); +% Precalculate +T_vol2mc = headvol.T_2mc; +fwmodel = genSensitivityProfileFromFluenceProf(fwmodel, probe, T_vol2mc, currFolder); + +end + +function SaveData(dc)%, Adot) +%output = load('homerOutput/test_john.mat'); +load('fw/Adot.mat'); +%load('homerOutput/atlasViewer.mat') +%data = load('trials_markers'); +%times = output.output.dc.time; + +dc_HbO=dc.dataTimeSeries(:,1:3:length(dc.dataTimeSeries)); +dc_HbO(isnan(dc_HbO))=0; +save('timeseries_HbO.mat', 'dc_HbO') +dc_HbR=dc.dataTimeSeries(:,2:3:length(dc.dataTimeSeries)); +dc_HbR(isnan(dc_HbR))=0; +dc_HbR = dc_HbR; +save('timeseries_HbR.mat', 'dc_HbR') + +alpha = 1e-6; +tmp=size(Adot); +n_channels = tmp(1); +n_vert = tmp(2); +A= Adot(:,:,1); +tmp= sort(diag(A*A')); +loc_min = find(tmp>0.001); +lambda= tmp(loc_min(1)); +tmp= A'/(A*A'+lambda*eye(n_channels)); +save('transform_channel2vertice_HbO.mat', 'tmp') +A= Adot(:,:,2); +tmp= sort(eig(A*A'));%sort(diag(A*A')); +loc_min = find(tmp>0.001); +lambda= tmp(loc_min(1)); +tmp= A'/(A*A'+lambda*eye(n_channels)); +save('transform_channel2vertice_HbR.mat', 'tmp') + +end \ No newline at end of file From a9f59e240a991ad85233f22e10db1d605c1597f7 Mon Sep 17 00:00:00 2001 From: John Wang Date: Mon, 22 Nov 2021 15:25:37 -0500 Subject: [PATCH 2/6] add notebook for brain plot from homer --- kftools/homer/fnirs_Homer_Atlas_brainplot.ipynb | 1 + 1 file changed, 1 insertion(+) create mode 100644 kftools/homer/fnirs_Homer_Atlas_brainplot.ipynb diff --git a/kftools/homer/fnirs_Homer_Atlas_brainplot.ipynb b/kftools/homer/fnirs_Homer_Atlas_brainplot.ipynb new file mode 100644 index 0000000..6c9577a --- /dev/null +++ b/kftools/homer/fnirs_Homer_Atlas_brainplot.ipynb @@ -0,0 +1 @@ +{"nbformat":4,"nbformat_minor":0,"metadata":{"colab":{"name":"fnirs_Homer_Atlas_brainplot.ipynb","provenance":[{"file_id":"1jzMvfdm2Fg7d8zUt8q6Bc8WCJMODIg7_","timestamp":1637357967461}],"collapsed_sections":[],"machine_shape":"hm"},"kernelspec":{"name":"python3","display_name":"Python 3"},"language_info":{"name":"python"}},"cells":[{"cell_type":"code","metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"s_UgjgtnGIwR","executionInfo":{"status":"ok","timestamp":1637610910931,"user_tz":300,"elapsed":27799,"user":{"displayName":"John Wang","photoUrl":"https://lh3.googleusercontent.com/a/default-user=s64","userId":"12306131614242280236"}},"outputId":"e48cdfee-a3ce-4020-af4a-588288ebabad"},"source":["from google.colab import drive\n","drive.mount('/content/drive')"],"execution_count":1,"outputs":[{"output_type":"stream","name":"stdout","text":["Mounted at /content/drive\n"]}]},{"cell_type":"code","metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"JzjwyG82IGfH","executionInfo":{"status":"ok","timestamp":1637610911729,"user_tz":300,"elapsed":806,"user":{"displayName":"John Wang","photoUrl":"https://lh3.googleusercontent.com/a/default-user=s64","userId":"12306131614242280236"}},"outputId":"506ed75a-2a3c-4d07-acbe-3154a81e3ab7"},"source":["cd /content/drive/MyDrive/Work/Sciencing/Data"],"execution_count":2,"outputs":[{"output_type":"stream","name":"stdout","text":["/content/drive/MyDrive/Work/Sciencing/Data\n"]}]},{"cell_type":"code","metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"wJPybQoQdJy8","executionInfo":{"status":"ok","timestamp":1637610955109,"user_tz":300,"elapsed":6068,"user":{"displayName":"John Wang","photoUrl":"https://lh3.googleusercontent.com/a/default-user=s64","userId":"12306131614242280236"}},"outputId":"b1f76715-804a-426a-c6de-574cd686aaad"},"source":["!pip install nilearn"],"execution_count":3,"outputs":[{"output_type":"stream","name":"stdout","text":["Collecting nilearn\n"," Downloading nilearn-0.8.1-py3-none-any.whl (10.0 MB)\n","\u001b[K |████████████████████████████████| 10.0 MB 4.0 MB/s \n","\u001b[?25hRequirement already satisfied: scikit-learn>=0.21 in /usr/local/lib/python3.7/dist-packages (from nilearn) (1.0.1)\n","Requirement already satisfied: nibabel>=2.5 in /usr/local/lib/python3.7/dist-packages (from nilearn) (3.0.2)\n","Requirement already satisfied: pandas>=0.24.0 in /usr/local/lib/python3.7/dist-packages (from nilearn) (1.1.5)\n","Requirement already satisfied: requests>=2 in /usr/local/lib/python3.7/dist-packages (from nilearn) (2.23.0)\n","Requirement already satisfied: scipy>=1.2 in /usr/local/lib/python3.7/dist-packages (from nilearn) (1.4.1)\n","Requirement already satisfied: joblib>=0.12 in /usr/local/lib/python3.7/dist-packages (from nilearn) (1.1.0)\n","Requirement already satisfied: numpy>=1.16 in /usr/local/lib/python3.7/dist-packages (from nilearn) (1.19.5)\n","Requirement already satisfied: python-dateutil>=2.7.3 in /usr/local/lib/python3.7/dist-packages (from pandas>=0.24.0->nilearn) (2.8.2)\n","Requirement already satisfied: pytz>=2017.2 in /usr/local/lib/python3.7/dist-packages (from pandas>=0.24.0->nilearn) (2018.9)\n","Requirement already satisfied: six>=1.5 in /usr/local/lib/python3.7/dist-packages (from python-dateutil>=2.7.3->pandas>=0.24.0->nilearn) (1.15.0)\n","Requirement already satisfied: certifi>=2017.4.17 in /usr/local/lib/python3.7/dist-packages (from requests>=2->nilearn) (2021.10.8)\n","Requirement already satisfied: idna<3,>=2.5 in /usr/local/lib/python3.7/dist-packages (from requests>=2->nilearn) (2.10)\n","Requirement already satisfied: urllib3!=1.25.0,!=1.25.1,<1.26,>=1.21.1 in /usr/local/lib/python3.7/dist-packages (from requests>=2->nilearn) (1.24.3)\n","Requirement already satisfied: chardet<4,>=3.0.2 in /usr/local/lib/python3.7/dist-packages (from requests>=2->nilearn) (3.0.4)\n","Requirement already satisfied: threadpoolctl>=2.0.0 in /usr/local/lib/python3.7/dist-packages (from scikit-learn>=0.21->nilearn) (3.0.0)\n","Installing collected packages: nilearn\n","Successfully installed nilearn-0.8.1\n"]}]},{"cell_type":"code","metadata":{"id":"dj_x8mhEMIjG","executionInfo":{"status":"ok","timestamp":1637610955109,"user_tz":300,"elapsed":4,"user":{"displayName":"John Wang","photoUrl":"https://lh3.googleusercontent.com/a/default-user=s64","userId":"12306131614242280236"}}},"source":["### data #####\n","### tast audio task\n","### Daniel's data\n","# \"test-004_fb46b0d_3.snirf\"\n","\n","# \" run Homer_Atlas.m\"\n","\n","# output:\n","# "],"execution_count":4,"outputs":[]},{"cell_type":"code","metadata":{"id":"liaYByRByinr","executionInfo":{"status":"ok","timestamp":1637358235166,"user_tz":300,"elapsed":115,"user":{"displayName":"John Wang","photoUrl":"https://lh3.googleusercontent.com/a/default-user=s64","userId":"12306131614242280236"}}},"source":["import numpy as np"],"execution_count":4,"outputs":[]},{"cell_type":"code","metadata":{"id":"KUM2BQ50IlPb","colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"status":"ok","timestamp":1637611053485,"user_tz":300,"elapsed":1577,"user":{"displayName":"John Wang","photoUrl":"https://lh3.googleusercontent.com/a/default-user=s64","userId":"12306131614242280236"}},"outputId":"14720cf4-3f77-4584-9607-ea3da2febb6f"},"source":["import matplotlib.pyplot as plt\n","import numpy as np\n","from numpy import exp,sin,cos,sqrt,pi, r_,floor,zeros\n","import scipy.io\n","from matplotlib.tri import Triangulation\n","from nilearn import plotting, datasets \n","from matplotlib import cm\n","from matplotlib.pyplot import subplot"],"execution_count":8,"outputs":[{"output_type":"stream","name":"stderr","text":["/usr/local/lib/python3.7/dist-packages/nilearn/datasets/__init__.py:96: FutureWarning: Fetchers from the nilearn.datasets module will be updated in version 0.9 to return python strings instead of bytes and Pandas dataframes instead of Numpy arrays.\n"," \"Numpy arrays.\", FutureWarning)\n"]}]},{"cell_type":"code","metadata":{"id":"77PyEEtlKUFa","executionInfo":{"status":"ok","timestamp":1637611059960,"user_tz":300,"elapsed":2433,"user":{"displayName":"John Wang","photoUrl":"https://lh3.googleusercontent.com/a/default-user=s64","userId":"12306131614242280236"}}},"source":["# load coordinates of vertices and face \n","ver = (scipy.io.loadmat('vertice_cood.mat'))['tmp']\n","face = (scipy.io.loadmat('face_cood.mat'))['tmp']"],"execution_count":9,"outputs":[]},{"cell_type":"code","metadata":{"id":"5UhJLTweVmU9","executionInfo":{"status":"ok","timestamp":1637611818864,"user_tz":300,"elapsed":14887,"user":{"displayName":"John Wang","photoUrl":"https://lh3.googleusercontent.com/a/default-user=s64","userId":"12306131614242280236"}}},"source":["# load channel data HbO and HbR from homer3\n","data_ch_O = (scipy.io.loadmat('timeseries_HbO.mat'))['dc_HbO']\n","data_ch_R = (scipy.io.loadmat('timeseries_HbR.mat'))['dc_HbR']\n","# load transformation matrix from channels to vertices\n","x_tran_O = (scipy.io.loadmat('transform_channel2vertice_HbO.mat'))['tmp']\n","x_tran_R = (scipy.io.loadmat('transform_channel2vertice_HbR.mat'))['tmp']"],"execution_count":26,"outputs":[]},{"cell_type":"code","metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"2jW4MXnOSoq1","executionInfo":{"status":"ok","timestamp":1637611818865,"user_tz":300,"elapsed":35,"user":{"displayName":"John Wang","photoUrl":"https://lh3.googleusercontent.com/a/default-user=s64","userId":"12306131614242280236"}},"outputId":"cfaf691a-4f02-4fb9-f9cd-4577838891e2"},"source":["data_ch_O.shape\n"],"execution_count":27,"outputs":[{"output_type":"execute_result","data":{"text/plain":["(4301, 2206)"]},"metadata":{},"execution_count":27}]},{"cell_type":"code","metadata":{"id":"-KlkeSZ4W6UH","executionInfo":{"status":"ok","timestamp":1637611830217,"user_tz":300,"elapsed":11356,"user":{"displayName":"John Wang","photoUrl":"https://lh3.googleusercontent.com/a/default-user=s64","userId":"12306131614242280236"}}},"source":["# convert data from channels to vertices using transformation matrix\n","ver_ts_O = x_tran_O @ data_ch_O.T\n","ver_ts_R = x_tran_R @ data_ch_R.T"],"execution_count":28,"outputs":[]},{"cell_type":"code","metadata":{"id":"WNxZLy5xCDht","executionInfo":{"status":"ok","timestamp":1637611830219,"user_tz":300,"elapsed":9,"user":{"displayName":"John Wang","photoUrl":"https://lh3.googleusercontent.com/a/default-user=s64","userId":"12306131614242280236"}}},"source":["# making a hemi file\n","hemi = np.ones((ver.shape[0],))\n","hemi[:ver.shape[0]//2] =0"],"execution_count":29,"outputs":[]},{"cell_type":"code","metadata":{"id":"jTKlEaYXV7Hp","executionInfo":{"status":"ok","timestamp":1637611830220,"user_tz":300,"elapsed":8,"user":{"displayName":"John Wang","photoUrl":"https://lh3.googleusercontent.com/a/default-user=s64","userId":"12306131614242280236"}}},"source":["_cm = 'RdBu_r'\n","kws = {'edgecolors': 'k', 'cmap': _cm, #$ 'Reds_r', #RdBu_r', # jet', \n"," 'vmax': .02,'vmin': 0, 'alpha': None, 'linewidth': 0.05}"],"execution_count":30,"outputs":[]},{"cell_type":"code","metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"fYePknGGU41G","executionInfo":{"status":"ok","timestamp":1637611943560,"user_tz":300,"elapsed":339,"user":{"displayName":"John Wang","photoUrl":"https://lh3.googleusercontent.com/a/default-user=s64","userId":"12306131614242280236"}},"outputId":"dadd5c28-32e9-4c4a-b675-744c8fcdbbb0"},"source":["ver.max()"],"execution_count":37,"outputs":[{"output_type":"execute_result","data":{"text/plain":["220.08217145525245"]},"metadata":{},"execution_count":37}]},{"cell_type":"code","metadata":{"colab":{"base_uri":"https://localhost:8080/","height":234},"id":"NkZS13CvVhsA","executionInfo":{"status":"ok","timestamp":1637611835322,"user_tz":300,"elapsed":4837,"user":{"displayName":"John Wang","photoUrl":"https://lh3.googleusercontent.com/a/default-user=s64","userId":"12306131614242280236"}},"outputId":"dfb74964-e9ec-4dd9-c563-e98f43f3ce5e"},"source":["# plot brain of norm of timeseries at each vertice\n","plot_surface_mpl_mv(vtx=ver-1, tri=face-1, data=np.linalg.norm(ver_ts_O,axis=1), reorient='fs', hemi=hemi, shade_kwargs=kws)"],"execution_count":32,"outputs":[{"output_type":"display_data","data":{"image/png":"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\n","text/plain":["
"]},"metadata":{"needs_background":"light"}}]},{"cell_type":"code","metadata":{"colab":{"base_uri":"https://localhost:8080/","height":234},"id":"9oqm1WnvB_qG","executionInfo":{"status":"ok","timestamp":1637611847601,"user_tz":300,"elapsed":4987,"user":{"displayName":"John Wang","photoUrl":"https://lh3.googleusercontent.com/a/default-user=s64","userId":"12306131614242280236"}},"outputId":"faae5440-b522-4529-a05a-1649d1723562"},"source":["# plot brain of norm of timeseries at each vertice\n","plot_surface_mpl_mv(vtx=ver-1, tri=face-1, data=np.linalg.norm(ver_ts_R,axis=1), reorient='fs', hemi=hemi, shade_kwargs=kws)"],"execution_count":34,"outputs":[{"output_type":"display_data","data":{"image/png":"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\n","text/plain":["
"]},"metadata":{"needs_background":"light"}}]},{"cell_type":"code","metadata":{"id":"NiX1UDHcXQer","executionInfo":{"status":"ok","timestamp":1637358492837,"user_tz":300,"elapsed":15233,"user":{"displayName":"John Wang","photoUrl":"https://lh3.googleusercontent.com/a/default-user=s64","userId":"12306131614242280236"}}},"source":["# resting \n","# load channel data HbO and HbR from homer3\n","data_ch_O = (scipy.io.loadmat('timeseries_HbO_rec.mat'))['dc_HbO']\n","data_ch_R = (scipy.io.loadmat('timeseries_HbR_rec.mat'))['dc_HbR']\n","# load transformation matrix from channels to vertices\n","x_tran_O = (scipy.io.loadmat('transform_channel2vertice_HbO_rec.mat'))['tmp']\n","x_tran_R = (scipy.io.loadmat('transform_channel2vertice_HbR_rec.mat'))['tmp']\n","\n","# convert data from channels to vertices using transformation matrix\n","ver_ts_O = x_tran_O @ data_ch_O.T\n","ver_ts_R = x_tran_R @ data_ch_R.T"],"execution_count":16,"outputs":[]},{"cell_type":"code","metadata":{"id":"HJDkWmS4Xqoq","executionInfo":{"status":"ok","timestamp":1637358492838,"user_tz":300,"elapsed":4,"user":{"displayName":"John Wang","photoUrl":"https://lh3.googleusercontent.com/a/default-user=s64","userId":"12306131614242280236"}}},"source":["_cm = 'RdBu_r'\n","kws = {'edgecolors': 'k', 'cmap': _cm, #$ 'Reds_r', #RdBu_r', # jet', \n"," 'vmax': .02,'vmin': 0, 'alpha': None, 'linewidth': 0.05}"],"execution_count":17,"outputs":[]},{"cell_type":"code","metadata":{"colab":{"base_uri":"https://localhost:8080/","height":234},"id":"636wApiLX4dK","executionInfo":{"status":"ok","timestamp":1637358496910,"user_tz":300,"elapsed":4075,"user":{"displayName":"John Wang","photoUrl":"https://lh3.googleusercontent.com/a/default-user=s64","userId":"12306131614242280236"}},"outputId":"d789e729-1b9d-4566-e92b-925e23245cc4"},"source":["# plot brain of norm of timeseries at each vertice\n","plot_surface_mpl_mv(vtx=ver-1, tri=face-1, data=np.linalg.norm(ver_ts_O,axis=1), reorient='fs', hemi=hemi)"],"execution_count":18,"outputs":[{"output_type":"display_data","data":{"image/png":"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\n","text/plain":["
"]},"metadata":{"needs_background":"light"}}]},{"cell_type":"code","metadata":{"colab":{"base_uri":"https://localhost:8080/","height":234},"id":"hOWc_acSX8z5","executionInfo":{"status":"ok","timestamp":1637358501125,"user_tz":300,"elapsed":4219,"user":{"displayName":"John Wang","photoUrl":"https://lh3.googleusercontent.com/a/default-user=s64","userId":"12306131614242280236"}},"outputId":"2b2e175a-043b-4039-e921-ead874a95e1a"},"source":["# plot brain of norm of timeseries at each vertice\n","plot_surface_mpl_mv(vtx=ver-1, tri=face-1, data=np.linalg.norm(ver_ts_R,axis=1), reorient='fs', hemi=hemi)"],"execution_count":19,"outputs":[{"output_type":"display_data","data":{"image/png":"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\n","text/plain":["
"]},"metadata":{"needs_background":"light"}}]},{"cell_type":"code","metadata":{"id":"-GZYCC6LDpjb","cellView":"form","executionInfo":{"status":"ok","timestamp":1637610963599,"user_tz":300,"elapsed":277,"user":{"displayName":"John Wang","photoUrl":"https://lh3.googleusercontent.com/a/default-user=s64","userId":"12306131614242280236"}}},"source":["def plot_surface_mpl(vtx,tri,data=None,rm=None,reorient='tvb',view='superior',\n"," shaded=False,ax=None,figsize=(6,4), title=None,\n"," lthr=None,uthr=None, nz_thr = 1E-20,\n"," shade_kwargs = {'edgecolors': 'k', 'linewidth': 0.1,\n"," 'alpha': None, 'cmap': 'coolwarm',\n"," 'vmin': None, 'vmax': None}):\n"," \n"," r\"\"\"Plot surfaces, surface patterns, and region patterns with matplotlib\n"," \n"," This is a general-use function for neuroimaging surface-based data, and \n"," does not necessarily require construction of or interaction with tvb \n"," datatypes. \n","\n"," See also: plot_surface_mpl_mv\n","\n","\n","\n"," Parameters\n"," ----------\n"," \n"," vtx : N vertices x 3 array of surface vertex xyz coordinates \n","\n"," tri : N faces x 3 array of surface faces\n","\n"," data : array of numbers to colour surface with. Can be either \n"," a pattern across surface vertices (N vertices x 1 array),\n"," or a pattern across the surface's region mapping \n"," (N regions x 1 array), in which case the region mapping \n"," bust also be given as an argument. \n"," \n"," rm : region mapping - N vertices x 1 array with (up to) N \n"," regions unique values; each element specifies which \n"," region the corresponding surface vertex is mapped to \n","\n"," reorient : modify the vertex coordinate frame and/or orientation \n"," so that the same default rotations can subsequently be \n"," used for image views. The standard coordinate frame is \n"," xyz; i.e. first,second,third axis = left-right, \n"," front-back, and up-down, respectively. The standard \n"," starting orientation is axial view; i.e. looking down on\n"," the brain in the x-y plane.\n"," \n"," Options: \n","\n"," tvb (default) : swaps the first 2 axes and applies a rotation\n"," \n"," fs : for the standard freesurfer (RAS) orientation; \n"," e.g. fsaverage lh.orig. \n"," No transformations needed for this; so is \n"," gives same result as reorient=None\n","\n"," view : specify viewing angle. \n"," \n"," This can be done in one of two ways: by specifying a string \n"," corresponding to a standard viewing angle, or by providing \n"," a tuple or list of tuples detailing exact rotations to apply \n"," around each axis. \n"," \n"," Standard view options are:\n"," \n"," lh_lat / lh_med / rh_lat / rh_med / \n"," superior / inferior / posterior / anterior\n","\n"," (Note: if the surface contains both hemispheres, then medial \n"," surfaces will not be visible, so e.g. 'rh_med' will look the \n"," same as 'lh_lat')\n"," \n"," Arbitrary rotations can be specied by a tuple or a list of \n"," tuples, each with two elements, the first defining the axis \n"," to rotate around [0,1,2], the second specifying the angle in \n"," degrees. When a list is given the rotations are applied \n"," sequentially in the order given. \n"," \n"," Example: rotations = [(0,45),(1,-45)] applies 45 degrees \n"," rotation around the first axis, followed by 45 degrees rotate \n"," around the second axis. \n","\n"," lthr/uthr : lower/upper thresholds - set to zero any datapoints below / \n"," above these values\n"," \n"," nz_thr : near-zero threshold - set to zero all datapoints with absolute \n"," values smaller than this number. Default is a very small \n"," number (1E-20), which unless your data has very small numbers, \n"," will only mask out actual zeros. \n","\n"," shade_kwargs : dictionary specifiying shading options\n","\n"," Most relevant options (see matplotlib 'tripcolor' for full details):\n"," \n"," - 'shading' (either 'gourand' or omit; \n"," default is 'flat')\n"," - 'edgecolors' 'k' = black is probably best\n"," - 'linewidth' 0.1 works well; note that the visual \n"," effect of this will depend on both the \n"," surface density and the figure size \n"," - 'cmap' colormap\n"," - 'vmin'/'vmax' scale colormap to these values\n"," - 'alpha' surface opacity\n"," \n"," ax : figure axis\n"," \n"," figsize : figure size (ignore if ax provided)\n"," \n"," title : text string to place above figure\n"," \n"," \n"," \n"," \n"," Usage\n"," -----\n"," \n","\n"," Basic freesurfer example:\n","\n"," import nibabel as nib\n"," vtx,tri = nib.freesurfer.read_geometry('subjects/fsaverage/surf/lh.orig')\n"," plot_surface_mpl(vtx,tri,view='lh_lat',reorient='fs')\n","\n","\n","\n"," Basic tvb example:\n"," \n"," ctx = cortex.Cortex.from_file(source_file = ctx_file,\n"," region_mapping_file =rm_file)\n"," vtx,tri,rm = ctx.vertices,ctx.triangles,ctx.region_mapping\n"," conn = connectivity.Connectivity.from_file(conn_file); conn.configure()\n"," isrh_reg = conn.is_right_hemisphere(range(conn.number_of_regions))\n"," isrh_vtx = np.array([isrh_reg[r] for r in rm])\n"," dat = conn.tract_lengths[:,5]\n","\n"," plot_surface_mpl(vtx=vtx,tri=tri,rm=rm,data=dat,view='inferior',title='inferior')\n","\n"," fig, ax = plt.subplots()\n"," plot_surface_mpl(vtx=vtx,tri=tri,rm=rm,data=dat, view=[(0,-90),(1,55)],ax=ax,\n"," title='lh angle',shade_kwargs={'shading': 'gouraud', 'cmap': 'rainbow'})\n","\n"," \n"," \"\"\"\n"," \n"," # Copy things to make sure we don't modify things \n"," # in the namespace inadvertently. \n"," \n"," vtx,tri = vtx.copy(),tri.copy()\n"," if data is not None: data = data.copy()\n","\n"," # 1. Set the viewing angle \n"," \n"," if reorient == 'tvb':\n"," # The tvb default brain has coordinates in the order \n"," # yxz for some reason. So first change that: \n"," vtx = np.array([vtx[:,1],vtx[:,0],vtx[:,2]]).T.copy()\n"," \n"," # Also need to reflect in the x axis\n"," vtx[:,0]*=-1\n","\n"," # (reorient == 'fs' is same as reorient=None; so not strictly needed\n"," # but is included for clarity)\n"," \n","\n","\n"," # ...get rotations for standard view options\n"," \n"," if view == 'lh_lat' : rots = [(0,-90),(1,90) ]\n"," elif view == 'lh_med' : rots = [(0,-90),(1,-90) ] \n"," elif view == 'rh_lat' : rots = [(0,-90),(1,-90) ]\n"," elif view == 'rh_med' : rots = [(0,-90),(1,90) ]\n"," elif view == 'superior' : rots = None\n"," elif view == 'inferior' : rots = (1,180)\n"," elif view == 'anterior' : rots = (0,-90)\n"," elif view == 'posterior' : rots = [(0, -90),(1,180)]\n"," elif (type(view) == tuple) or (type(view) == list): rots = view \n","\n"," # (rh_lat is the default 'view' argument because no rotations are \n"," # for that one; so if no view is specified when the function is called, \n"," # the 'rh_lat' option is chose here and the surface is shown 'as is' \n"," \n"," \n"," # ...apply rotations \n"," \n"," if rots is None: rotmat = np.eye(3)\n"," else: rotmat = get_combined_rotation_matrix(rots)\n"," vtx = np.dot(vtx,rotmat)\n","\n"," \n"," \n"," # 2. Sort out the data\n"," \n"," \n"," # ...if no data is given, plot a vector of 1s. \n"," # if using region data, create corresponding surface vector \n"," if data is None: \n"," data = np.ones(vtx.shape[0]) \n"," elif data.shape[0] != vtx.shape[0]: \n"," data = np.array([data[r] for r in rm])\n"," \n"," # ...apply thresholds\n"," if uthr: data *= (data < uthr)\n"," if lthr: data *= (data > lthr)\n"," data *= (np.abs(data) > nz_thr)\n","\n"," \n"," # 3. Create the surface triangulation object \n"," \n"," x,y,z = vtx.T\n"," tx,ty,tz = vtx[tri].mean(axis=1).T\n"," tr = Triangulation(x,y,tri[np.argsort(tz)])\n"," \n"," # 4. Make the figure \n","\n"," if ax is None: fig, ax = plt.subplots(figsize=figsize) \n"," \n"," #if shade = 'gouraud': shade_opts['shade'] = \n"," tc = ax.tripcolor(tr, np.squeeze(data), **shade_kwargs)\n"," \n"," ax.set_aspect('equal')\n"," ax.axis('off')\n"," \n"," if title is not None: ax.set_title(title)\n"," return tc\n","#@title function for plotting surface"],"execution_count":5,"outputs":[]},{"cell_type":"code","metadata":{"id":"_B7fFjKk5x4X","cellView":"form","executionInfo":{"status":"ok","timestamp":1637610963858,"user_tz":300,"elapsed":2,"user":{"displayName":"John Wang","photoUrl":"https://lh3.googleusercontent.com/a/default-user=s64","userId":"12306131614242280236"}}},"source":["def plot_surface_mpl_mv(vtx=None,tri=None,data=None,rm=None,hemi=None, # Option 1\n"," vtx_lh=None,tri_lh=None,data_lh=None,rm_lh=None, # Option 2\n"," vtx_rh=None,tri_rh=None,data_rh=None,rm_rh=None,\n"," title=None,**kwargs):\n","\n"," r\"\"\"Convenience wrapper on plot_surface_mpl for multiple views \n"," \n"," This function calls plot_surface_mpl five times to give a complete \n"," picture of a surface- or region-based spatial pattern. \n","\n"," As with plot_surface_mpl, this function is written so as to be \n"," generally usable with neuroimaging surface-based data, and does not \n"," require construction of of interaction with tvb datatype objects. \n","\n"," In order for the medial surfaces to be displayed properly, it is \n"," necessary to separate the left and right hemispheres. This can be \n"," done in one of two ways: \n","\n"," 1. Provide single arrays for vertices, faces, data, and \n"," region mappings, and addition provide arrays of indices for \n"," each of these (vtx_inds,tr_inds,rm_inds) with 0/False \n"," indicating left hemisphere vertices/faces/regions, and 1/True \n"," indicating right hemisphere. \n","\n"," Note: this requires that \n","\n"," 2. Provide separate vertices,faces,data,and region mappings for \n"," each hemisphere (vtx_lh,tri_lh; vtx_rh,tri_rh,etc...)\n","\n","\n"," \n"," Parameters\n"," ----------\n","\n"," (see also plot_surface_mpl parameters info for more details)\n","\n"," (Option 1)\n","\n"," vtx : surface vertices\n"," \n"," tri : surface faces\n","\n"," data : spatial pattern to plot\n","\n"," rm : surface vertex to region mapping\n","\n"," hemi : hemisphere labels for each vertex\n"," (1/True = right, 0/False = left) - \n"," \n","\n"," OR\n","\n"," (Option 2)\n","\n"," vtx_lh : left hemisphere surface_vertices\n"," vtx_rh : right `` `` `` ``\n"," \n"," tri_lh : left hemisphere surface faces \n"," tri_rh : right `` `` `` ``\n","\n"," data_lh : left hemisphere surface_vertices\n"," data_rh : right `` `` `` ``\n","\n"," rm_lh : left hemisphere region_mapping\n"," rm_rh : right `` `` `` ``\n","\n","\n"," title : title to show above middle plot\n"," \n"," kwargs : additional tripcolor kwargs; see plot_surface_mpl\n","\n"," \n","\n"," Examples\n"," ----------\n","\n"," # TVB default data\n","\n"," # Plot one column of the region-based tract lengths \n"," # connectivity matrix. The corresponding region is \n"," # right auditory cortex ('rA1')\n","\n"," ctx = cortex.Cortex.from_file(source_file = ctx_file,\n"," region_mapping_file =rm_file)\n"," vtx,tri,rm = ctx.vertices,ctx.triangles,ctx.region_mapping\n"," conn = connectivity.Connectivity.from_file(conn_file); conn.configure()\n"," isrh_reg = conn.is_right_hemisphere(range(conn.number_of_regions))\n"," isrh_vtx = np.array([isrh_reg[r] for r in rm])\n"," dat = conn.tract_lengths[:,5]\n","\n"," plot_surface_mpl_mv(vtx=vtx,tri=tri,rm=rm,data=dat,\n"," hemi=isrh_vtx,title=u'rA1 \\ntract length')\n","\n"," plot_surface_mpl_mv(vtx=vtx,tri=tri,rm=rm,data=dat,\n"," hemi=isrh_vtx,title=u'rA1 \\ntract length',\n"," shade_kwargs = {'shading': 'gouraud',\n"," 'cmap': 'rainbow'}) \n","\n","\n"," \"\"\"\n"," \n","\n"," \n"," if vtx is not None: # Option 1\n"," tri_hemi = hemi[tri].any(axis=1)\n"," tri_lh,tri_rh = tri[tri_hemi==0],tri[tri_hemi==1]\n"," elif vtx_lh is not None: # Option 2\n"," vtx = np.vstack([vtx_lh,vtx_rh])\n"," tri = np.vstack([tri_lh,tri_rh+tri_lh.max()+1])\n","\n"," if data_lh is not None: # Option 2\n"," data = np.hstack([data_lh,data_rh])\n"," \n"," if rm_lh is not None: # Option 2 \n"," rm = np.hstack([rm_lh,rm_rh + rm_lh.max() + 1])\n"," \n"," \n","\n"," # 2. Now do the plots for each view\n","\n"," # (Note: for the single hemispheres we only need lh/rh arrays for the \n"," # faces (tri); the full vertices, region mapping, and data arrays\n"," # can be given as arguments, they just won't be shown if they aren't \n"," # connected by the faces in tri )\n"," fig, ax = plt.subplots(2,3, figsize=(6,4))\n"," # LH lateral\n"," plot_surface_mpl(vtx,tri_lh,data=data,rm=rm,view='lh_lat',\n"," ax=subplot(2,3,1),**kwargs)\n"," \n"," # LH medial\n"," plot_surface_mpl(vtx,tri_lh, data=data,rm=rm,view='lh_med',\n"," ax=subplot(2,3,4),**kwargs)\n"," \n"," # RH lateral\n"," plot_surface_mpl(vtx,tri_rh, data=data,rm=rm,view='rh_lat',\n"," ax=subplot(2,3,3),**kwargs)\n"," \n"," # RH medial\n"," plot_surface_mpl(vtx,tri_rh, data=data,rm=rm,view='rh_med',\n"," ax=subplot(2,3,6),**kwargs)\n"," \n"," # Both superior\n"," im =plot_surface_mpl(vtx,tri, data=data,rm=rm,view='superior',\n"," ax=subplot(1,3,2),title=title,**kwargs)\n"," \n"," plt.subplots_adjust(left=0.0, right=.8, bottom=0.0,\n"," top=.8, wspace=0, hspace=0)\n"," cbar_ax = fig.add_axes([0.85,0.1,0.05,0.6])\n"," fig.colorbar(im, cax = cbar_ax)\n","\n"," #@title function for plot brain in one picture"],"execution_count":6,"outputs":[]},{"cell_type":"code","metadata":{"id":"9nFCkksrExTr","cellView":"form","executionInfo":{"status":"ok","timestamp":1637610964151,"user_tz":300,"elapsed":3,"user":{"displayName":"John Wang","photoUrl":"https://lh3.googleusercontent.com/a/default-user=s64","userId":"12306131614242280236"}}},"source":["#@title\n","def get_rotation_matrix(rotation_axis, deg):\n"," \n"," '''Return rotation matrix in the x,y,or z plane'''\n"," \n"," \n"," \n"," # (note make deg minus to change from anticlockwise to clockwise rotation)\n"," th = -deg * (pi/180) # convert degrees to radians\n"," \n"," if rotation_axis == 0:\n"," return np.array( [[ 1, 0, 0 ],\n"," [ 0, cos(th), -sin(th)],\n"," [ 0, sin(th), cos(th)]])\n"," elif rotation_axis ==1:\n"," return np.array( [[ cos(th), 0, sin(th)],\n"," [ 0, 1, 0 ],\n"," [ -sin(th), 0, cos(th)]])\n"," elif rotation_axis ==2:\n"," return np.array([[ cos(th), -sin(th), 0 ],\n"," [ sin(th), cos(th), 0 ],\n"," [ 0, 0, 1 ]])\n"," \n","\n","\n","def get_combined_rotation_matrix(rotations):\n"," '''Return a combined rotation matrix from a dictionary of rotations around \n"," the x,y,or z axes'''\n"," rotmat = np.eye(3)\n"," \n"," if type(rotations) is tuple: rotations = [rotations] \n"," for r in rotations:\n"," newrot = get_rotation_matrix(r[0],r[1])\n"," rotmat = np.dot(rotmat,newrot)\n"," return rotmat"],"execution_count":7,"outputs":[]},{"cell_type":"code","metadata":{"id":"ZKxt-NV1EQgH"},"source":[""],"execution_count":null,"outputs":[]}]} \ No newline at end of file From a56a1377c78f91c98c92b1daa4f1a063e24033bc Mon Sep 17 00:00:00 2001 From: John Wang Date: Wed, 24 Nov 2021 12:09:28 -0500 Subject: [PATCH 3/6] Update Homer_Atlas_2.m with full run --- kftools/homer/Homer_Atlas_2.m | 14 +++++++------- 1 file changed, 7 insertions(+), 7 deletions(-) diff --git a/kftools/homer/Homer_Atlas_2.m b/kftools/homer/Homer_Atlas_2.m index 600626c..c4ffece 100644 --- a/kftools/homer/Homer_Atlas_2.m +++ b/kftools/homer/Homer_Atlas_2.m @@ -5,12 +5,12 @@ %Then go to folder with digpts.txt, probe.SD and your snirf moments file function [dc,fwmodel] = Homer_Atlas(snirfFileName,dirname_atlas_viewer,currFolder) -%[fwmodel, probe] = ForwardModel(dirname_atlas_viewer, currFolder); +[fwmodel, probe] = ForwardModel(dirname_atlas_viewer, currFolder); snirf_data = MeanMoments(snirfFileName); -load('C:\Users\zheng_wang\Downloads\Homer3-master\Homer3-master\Test_John_FT\homerOutput\atlasViewer.mat'); +%load('C:\Users\zheng_wang\Downloads\Homer3-master\Homer3-master\Test_John_FT\homerOutput\atlasViewer.mat'); dc = HomerProcessing(snirf_data, probe); -%SaveData(dc,fwmodel.Adot); -SaveData(dc); +SaveData(dc,fwmodel.Adot); +%SaveData(dc); end @@ -303,9 +303,9 @@ end -function SaveData(dc)%, Adot) +function SaveData(dc, Adot) %output = load('homerOutput/test_john.mat'); -load('fw/Adot.mat'); +%load('fw/Adot.mat'); %load('homerOutput/atlasViewer.mat') %data = load('trials_markers'); %times = output.output.dc.time; @@ -335,4 +335,4 @@ function SaveData(dc)%, Adot) tmp= A'/(A*A'+lambda*eye(n_channels)); save('transform_channel2vertice_HbR.mat', 'tmp') -end \ No newline at end of file +end From 10c90320f25bde1e0804f6fc2f0d52c0c453cef0 Mon Sep 17 00:00:00 2001 From: sbastiaens <62792658+sbastiaens@users.noreply.github.com> Date: Fri, 26 Nov 2021 14:13:34 -0500 Subject: [PATCH 4/6] Added changes from Homer_Atlas_2.m --- kftools/homer/Homer_Atlas.m | 115 ++++++++++++++++++++++++++++++++---- 1 file changed, 103 insertions(+), 12 deletions(-) diff --git a/kftools/homer/Homer_Atlas.m b/kftools/homer/Homer_Atlas.m index d7e0197..272b872 100644 --- a/kftools/homer/Homer_Atlas.m +++ b/kftools/homer/Homer_Atlas.m @@ -4,10 +4,13 @@ %Then go to folder with digpts.txt, probe.SD and your snirf moments file function [dc,fwmodel] = Homer_Atlas(snirfFileName,dirname_atlas_viewer,currFolder) + +[fwmodel, probe] = ForwardModel(dirname_atlas_viewer, currFolder); snirf_data = MeanMoments(snirfFileName); -dc = HomerProcessing(snirf_data); -fwmodel = ForwardModel(dirname_atlas_viewer, currFolder); +%load('C:\Users\zheng_wang\Downloads\Homer3-master\Homer3-master\Test_John_FT\homerOutput\atlasViewer.mat'); +dc = HomerProcessing(snirf_data, probe); SaveData(dc,fwmodel.Adot); +%SaveData(dc); end @@ -28,7 +31,7 @@ % 2) Homer3 processing -function dc = HomerProcessing(res) +function dc = HomerProcessing(res, probe) %[pname, fname] = fileparts(filename); %if isempty(pname) % pname = pwd; @@ -43,13 +46,100 @@ % String together user functions to get from acquired data % to HRF %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% -dod = hmrR_Intensity2OD(acquired.data); -dod = hmrR_BandpassFilt(dod, 0.01, 0.50); -dc = hmrR_OD2Conc(dod, acquired.probe, [1,1]); +%data_dnan = acquired; +%tmp = acquired.data.dataTimeSeries; +%tmp(isnan(tmp))= mean(mean(); +%data_dnan.data.dataTimeSeries = tmp; +acquired.data.dataTimeSeries = hmrR_PreprocessIntensity_NAN(res.data); + +dod = hmrR_Intensity2OD(acquired.data); +dod_nan_rm = dod; +dod_nan_rm.dataTimeSeries = hmrR_PreprocessIntensity_NAN(dod); +dod = hmrR_BandpassFilt(dod_nan_rm, 0.01, 0.50); + +dod_nan_rm = dod; +dod_nan_rm.dataTimeSeries = hmrR_PreprocessIntensity_NAN(dod); +dc = hmrR_OD2Conc_zw(dod, acquired.probe, probe, [1,1]); +end + + + +function dc = hmrR_OD2Conc_zw( dod, probe, probe_true, ppf ) + +dc = DataClass().empty(); + +for ii=1:length(dod) + dc(ii) = DataClass(); + + Lambda = probe.GetWls(); + SrcPos_data = probe.GetSrcPos(); + SrcPos = probe_true.srcpos; + DetPos_data = probe.GetDetPos(); + DetPos = probe_true.detpos; + nWav = length(Lambda); + ml = dod(ii).GetMeasList(); + y = dod(ii).GetDataTimeSeries(); + + if length(ppf) < nWav + warning('Length of ppf does not match the number of wavelengths. Falling back to ppf=1 for all wavelengths.'); + ppf = ones(1, nWav); + elseif length(ppf) > nWav + d = length(ppf)-nWav; + ppf(end-d+1:end) = []; + end + + if ~isempty(find(ppf==1)) + ppf = ones(size(ppf)); + end + + nTpts = size(y,1); + + e = GetExtinctions(Lambda); + e = e(:,1:2) / 10; % convert from /cm to /mm + einv = inv( e'*e )*e'; + %size(einv) + + + for idx=1:length(probe_true.ml) + k = 3*(idx-1)+1; + %idx1 = lst(idx); + %idx2 = find( probe.ml(:,4)>1 & probe.ml(:,1)== probe.ml(idx1,1) & ml(:,2)==ml(idx1,2) ); + + rho = norm(SrcPos(probe_true.ml(idx,1),:)-DetPos(probe_true.ml(idx,2),:)); + + idx1 = find(ml(:,4) ==1 & ml(:,1) == probe_true.ml(idx,1) & ml(:,2)== probe_true.ml(idx,2) ); + idx2 = find(ml(:,4) ==2 & ml(:,1) == probe_true.ml(idx,1) & ml(:,2)== probe_true.ml(idx,2) ); + if isempty(idx1) + y_mean = ones(nTpts,2); + y_mean(:,1)=mean(y,2); + y_mean(:,2)=mean(y,2); + if ppf(1)~=1 + + y2(:,k:k+1) = ( einv * (y_mean./(ones(nTpts,1)*rho*ppf))' )'; + else + y2(:,k:k+1) = ( einv * (y_mean./(ones(nTpts,1)))' )'; + end + else + if ppf(1)~=1 + y2(:,k:k+1) = ( einv * (y(:,[idx1(1) idx2(1)'])./(ones(nTpts,1)*rho*ppf))' )'; + else + y2(:,k:k+1) = ( einv * (y(:,[idx1(1) idx2(1)'])./(ones(nTpts,1)))' )'; + end + end + y2(:,k+2) = y2(:,k) + y2(:,k+1); + dc(ii).AddChannelHbO(probe_true.ml(idx,1), probe_true.ml(idx,2)); + dc(ii).AddChannelHbR(probe_true.ml(idx,1), probe_true.ml(idx,2)); + dc(ii).AddChannelHbT(probe_true.ml(idx,1), probe_true.ml(idx,2)); + end + dc(ii).SetDataTimeSeries(y2); + dc(ii).SetTime(dod(ii).GetTime()); +end end + + % 3) AtlasViewer -function fwmodel = ForwardModel(dirname_atlas_viewer, currFolder) +function [fwmodel, probe] = ForwardModel(dirname_atlas_viewer, currFolder) % Registration from Digpoints (+register probe to surface) @@ -215,14 +305,15 @@ function SaveData(dc, Adot) %output = load('homerOutput/test_john.mat'); -%load('homerOutput/fw/Adot.mat'); +%load('fw/Adot.mat'); %load('homerOutput/atlasViewer.mat') %data = load('trials_markers'); %times = output.output.dc.time; -dc_HbO=dc.dataTimeSeries(:,1:3:6618); + +dc_HbO=dc.dataTimeSeries(:,1:3:length(dc.dataTimeSeries)); dc_HbO(isnan(dc_HbO))=0; save('timeseries_HbO.mat', 'dc_HbO') -dc_HbR=dc.dataTimeSeries(:,2:3:6618); +dc_HbR=dc.dataTimeSeries(:,2:3:length(dc.dataTimeSeries)); dc_HbR(isnan(dc_HbR))=0; dc_HbR = dc_HbR; save('timeseries_HbR.mat', 'dc_HbR') @@ -238,10 +329,10 @@ function SaveData(dc, Adot) tmp= A'/(A*A'+lambda*eye(n_channels)); save('transform_channel2vertice_HbO.mat', 'tmp') A= Adot(:,:,2); -tmp= sort(diag(A*A')); +tmp= sort(eig(A*A'));%sort(diag(A*A')); loc_min = find(tmp>0.001); lambda= tmp(loc_min(1)); tmp= A'/(A*A'+lambda*eye(n_channels)); save('transform_channel2vertice_HbR.mat', 'tmp') -end \ No newline at end of file +end From 5b86788c5995e3e310b20a87bf070d7502b766ca Mon Sep 17 00:00:00 2001 From: sbastiaens <62792658+sbastiaens@users.noreply.github.com> Date: Fri, 26 Nov 2021 14:14:37 -0500 Subject: [PATCH 5/6] Delete Homer_Atlas_2 Now Homer_Atlas.m and Homer_Atlas_2 are the same --- kftools/homer/Homer_Atlas_2.m | 338 ---------------------------------- 1 file changed, 338 deletions(-) delete mode 100644 kftools/homer/Homer_Atlas_2.m diff --git a/kftools/homer/Homer_Atlas_2.m b/kftools/homer/Homer_Atlas_2.m deleted file mode 100644 index c4ffece..0000000 --- a/kftools/homer/Homer_Atlas_2.m +++ /dev/null @@ -1,338 +0,0 @@ -% Pipeline Kernel Homer3 and AtlasViewer - -% NOTE: Beforehand do setpaths in Homer3 folder and add Atlas-viewer to the path. - -%Then go to folder with digpts.txt, probe.SD and your snirf moments file -function [dc,fwmodel] = Homer_Atlas(snirfFileName,dirname_atlas_viewer,currFolder) - -[fwmodel, probe] = ForwardModel(dirname_atlas_viewer, currFolder); -snirf_data = MeanMoments(snirfFileName); -%load('C:\Users\zheng_wang\Downloads\Homer3-master\Homer3-master\Test_John_FT\homerOutput\atlasViewer.mat'); -dc = HomerProcessing(snirf_data, probe); -SaveData(dc,fwmodel.Adot); -%SaveData(dc); -end - - -% 1) Get Mean of the moments - -function res = MeanMoments(snirfFileName) - -snirf = SnirfLoad(snirfFileName); %original file -snirf_cop = snirf; -timeSeries = snirf.data.dataTimeSeries; -measurementList = snirf.data.measurementList; - -snirf_cop.data.dataTimeSeries = timeSeries(:,2:3:length(timeSeries(1,:))); -snirf_cop.data.measurementList = measurementList(2:3:length(measurementList(1,:))); -%SnirfSave('../Test_ft_Renee/test_renee_ft.snirf', snirf_cop); -res = snirf_cop; -end - -% 2) Homer3 processing - -function dc = HomerProcessing(res, probe) -%[pname, fname] = fileparts(filename); -%if isempty(pname) -% pname = pwd; -%end -%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% -% Load acquisition file -%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% -% Acquired data (See SNIRF spec for list of acquired data parameters) -%acquired = SnirfClass([pname, '/', fname, '.snirf']); - -acquired = res; -% String together user functions to get from acquired data -% to HRF -%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% -%data_dnan = acquired; -%tmp = acquired.data.dataTimeSeries; -%tmp(isnan(tmp))= mean(mean(); -%data_dnan.data.dataTimeSeries = tmp; -acquired.data.dataTimeSeries = hmrR_PreprocessIntensity_NAN(res.data); - -dod = hmrR_Intensity2OD(acquired.data); -dod_nan_rm = dod; -dod_nan_rm.dataTimeSeries = hmrR_PreprocessIntensity_NAN(dod); -dod = hmrR_BandpassFilt(dod_nan_rm, 0.01, 0.50); - -dod_nan_rm = dod; -dod_nan_rm.dataTimeSeries = hmrR_PreprocessIntensity_NAN(dod); -dc = hmrR_OD2Conc_zw(dod, acquired.probe, probe, [1,1]); -end - - - -function dc = hmrR_OD2Conc_zw( dod, probe, probe_true, ppf ) - -dc = DataClass().empty(); - -for ii=1:length(dod) - dc(ii) = DataClass(); - - Lambda = probe.GetWls(); - SrcPos_data = probe.GetSrcPos(); - SrcPos = probe_true.srcpos; - DetPos_data = probe.GetDetPos(); - DetPos = probe_true.detpos; - nWav = length(Lambda); - ml = dod(ii).GetMeasList(); - y = dod(ii).GetDataTimeSeries(); - - if length(ppf) < nWav - warning('Length of ppf does not match the number of wavelengths. Falling back to ppf=1 for all wavelengths.'); - ppf = ones(1, nWav); - elseif length(ppf) > nWav - d = length(ppf)-nWav; - ppf(end-d+1:end) = []; - end - - if ~isempty(find(ppf==1)) - ppf = ones(size(ppf)); - end - - nTpts = size(y,1); - - e = GetExtinctions(Lambda); - e = e(:,1:2) / 10; % convert from /cm to /mm - einv = inv( e'*e )*e'; - %size(einv) - - - for idx=1:length(probe_true.ml) - k = 3*(idx-1)+1; - %idx1 = lst(idx); - %idx2 = find( probe.ml(:,4)>1 & probe.ml(:,1)== probe.ml(idx1,1) & ml(:,2)==ml(idx1,2) ); - - rho = norm(SrcPos(probe_true.ml(idx,1),:)-DetPos(probe_true.ml(idx,2),:)); - - idx1 = find(ml(:,4) ==1 & ml(:,1) == probe_true.ml(idx,1) & ml(:,2)== probe_true.ml(idx,2) ); - idx2 = find(ml(:,4) ==2 & ml(:,1) == probe_true.ml(idx,1) & ml(:,2)== probe_true.ml(idx,2) ); - if isempty(idx1) - y_mean = ones(nTpts,2); - y_mean(:,1)=mean(y,2); - y_mean(:,2)=mean(y,2); - if ppf(1)~=1 - - y2(:,k:k+1) = ( einv * (y_mean./(ones(nTpts,1)*rho*ppf))' )'; - else - y2(:,k:k+1) = ( einv * (y_mean./(ones(nTpts,1)))' )'; - end - else - if ppf(1)~=1 - y2(:,k:k+1) = ( einv * (y(:,[idx1(1) idx2(1)'])./(ones(nTpts,1)*rho*ppf))' )'; - else - y2(:,k:k+1) = ( einv * (y(:,[idx1(1) idx2(1)'])./(ones(nTpts,1)))' )'; - end - end - y2(:,k+2) = y2(:,k) + y2(:,k+1); - dc(ii).AddChannelHbO(probe_true.ml(idx,1), probe_true.ml(idx,2)); - dc(ii).AddChannelHbR(probe_true.ml(idx,1), probe_true.ml(idx,2)); - dc(ii).AddChannelHbT(probe_true.ml(idx,1), probe_true.ml(idx,2)); - end - dc(ii).SetDataTimeSeries(y2); - dc(ii).SetTime(dod(ii).GetTime()); -end -end - - - -% 3) AtlasViewer -function [fwmodel, probe] = ForwardModel(dirname_atlas_viewer, currFolder) - -% Registration from Digpoints (+register probe to surface) - -dirnameAtlas = [dirname_atlas_viewer, '/Data/Colin/']; -searchPaths = dirnameAtlas; - -headvol = initHeadvol(); -headsurf = initHeadsurf(); -pialsurf = initPialsurf(); -refpts = initRefpts(); -digpts = initDigpts(); -probe = initProbe(); -fwmodel = initFwmodel(); -labelssurf = initLabelssurf(); -imgrecon = initImgRecon(); - -headvol = getHeadvol(headvol, searchPaths); -headsurf = getHeadsurf(headsurf, searchPaths); -pialsurf = getPialsurf(pialsurf, searchPaths); - -headsurf.pathname = dirnameAtlas; -headvol.pathname = dirnameAtlas; - -refpts = getRefpts(refpts, headsurf.pathname); -labelssurf = getLabelssurf(labelssurf, headsurf.pathname); -fwmodel = getFwmodel(fwmodel, currFolder, pialsurf, headsurf, headvol, probe); -imgrecon = getImgRecon(imgrecon, currFolder, fwmodel, pialsurf, probe); - - - -%pwd = dirnameSubj -digpts = getDigpts(digpts, currFolder, refpts); - -probe = getProbe(probe, currFolder, digpts, headsurf, refpts); - - -% First determine transformation to monte carlo space from volume -% Generate transformation from head volume to digitized points space -[rp_atlas, rp_subj] = findCorrespondingRefpts(refpts, digpts); -headvol.T_2digpts = gen_xform_from_pts(rp_atlas, rp_subj); -headvol.imgOrig = headvol.img; - -% Register headvol to digpts but first check fwmodel if it's volume -% is already registered to digpts. if it is then set the headvol object -% to the fwmodel's headvol and reuse it. -if ~isregisteredFwmodel(fwmodel, headvol) - - [headvol.img, digpts.T_2mc] = ... - xform_apply_vol_smooth(headvol.img, headvol.T_2digpts); - - headvol.T_2mc = digpts.T_2mc * headvol.T_2digpts; - headvol.center = xform_apply(headvol.center, headvol.T_2mc); - headvol.orientation = digpts.orientation; - - % The MC space volume changed invalidating fwmodel meshes and - % vol to surface mesh. We need to recalculate all of this. - - % fwmodel = resetFwmodel(fwmodel, headvol); - % imgrecon = resetImgRecon(imgrecon); - -else - - % Reusing MC space headvol from fwmodel. - headvol = fwmodel.headvol; - - % We know that headvol.T_2mc = digpts.T_2mc * headvol.T_2digpts. - % Here we need to recover digpts.T_2mc. We can do this from - % headvol.T_2mc and headvol.T_2digpts with a little matrix algebra - digpts.T_2mc = headvol.T_2mc / headvol.T_2digpts; - -end - -digpts.refpts.pos = xform_apply(digpts.refpts.pos, digpts.T_2mc); -digpts.pcpos = xform_apply(digpts.pcpos, digpts.T_2mc); -digpts.srcpos = xform_apply(digpts.srcpos, digpts.T_2mc); -digpts.detpos = xform_apply(digpts.detpos, digpts.T_2mc); -digpts.optpos = [digpts.srcpos; digpts.detpos]; -digpts.center = digpts.refpts.center; - -% Copy digitized optodes to probe object -if ~isempty(probe.optpos_reg) - probe.optpos_reg = xform_apply(probe.optpos_reg, digpts.T_2mc * probe.T_2digpts); -else - probe.optpos_reg = xform_apply(probe.optpos, digpts.T_2mc * probe.T_2digpts); -end - -% move head surface to monte carlo space -headsurf.mesh.vertices = xform_apply(headsurf.mesh.vertices, headvol.T_2mc); -headsurf.center = xform_apply(headsurf.center, headvol.T_2mc); -headsurf.centerRotation = xform_apply(headsurf.centerRotation, headvol.T_2mc); - -% move pial surface to monte carlo space -pialsurf.mesh.vertices = xform_apply(pialsurf.mesh.vertices, headvol.T_2mc); -pialsurf.center = xform_apply(pialsurf.center, headvol.T_2mc); - -% move anatomical labels surface to monte carlo space -labelssurf.mesh.vertices = xform_apply(labelssurf.mesh.vertices, headvol.T_2mc); -labelssurf.center = xform_apply(labelssurf.center, headvol.T_2mc); - -% move ref points to monte carlo space -refpts = xform_apply_Refpts(refpts, headvol.T_2mc); - -% The fwmodel meshes are inherited from pial and head surf at init time. Therefore they are -% in original unregistered volume space, not MC space. Therefore we have to transform it to -% MC space. -fwmodel.mesh.vertices = xform_apply(fwmodel.mesh.vertices, headvol.T_2mc); -fwmodel.mesh_scalp.vertices = xform_apply(fwmodel.mesh_scalp.vertices, headvol.T_2mc); -fwmodel.mesh_orig.vertices = xform_apply(fwmodel.mesh_orig.vertices, headvol.T_2mc); -fwmodel.mesh_scalp_orig.vertices = xform_apply(fwmodel.mesh_scalp_orig.vertices, headvol.T_2mc); - -% The imgrecon meshes are inherited from pial surf at init time. Therefore they are -% in original unregistered volume space, not MC space. Therefore we have to transform it to -% MC space. -imgrecon.mesh.vertices = xform_apply(imgrecon.mesh.vertices, headvol.T_2mc); -imgrecon.mesh_orig.vertices = xform_apply(imgrecon.mesh_orig.vertices, headvol.T_2mc); - -% Finish Registration -if ~headsurf.isempty(headsurf) - headobj = headsurf; -else - headobj = headvol; -end - -refpts.eeg_system.selected = '10-5'; -refpts = set_eeg_active_pts(refpts, [], false); -% Finish registration -if isempty(probe.al) - - % Register probe by simply pulling (or pushing) optodes toward surface - % toward (or away from) center of head. - method = 'digpts'; - probe = pullProbeToHeadsurf(probe, headobj); - probe.hOptodesIdx = 1; - -else - - % Register probe using springs based method - if headvol.isempty(headvol) - menu('Error registering probe using spring relaxation. Headvol object is empty','OK'); - return; - end - method = 'springs'; - probe = probeRegisterSpringsMethod(probe, headvol, refpts); - -end - - -% View registered optodes on the head surface -%probe = viewProbe(probe, 'registered'); - -% Draw measurement list and save handle -%probe = findMeasMidPts(probe); - -%fwmodel = updateGuiControls_AfterProbeRegistration(probe, fwmodel, imgrecon, labelssurf); - -%probe.hOptodesIdx = 1; -%probe = setProbeDisplay(probe, headsurf, method); -% Precalculate -T_vol2mc = headvol.T_2mc; -fwmodel = genSensitivityProfileFromFluenceProf(fwmodel, probe, T_vol2mc, currFolder); - -end - -function SaveData(dc, Adot) -%output = load('homerOutput/test_john.mat'); -%load('fw/Adot.mat'); -%load('homerOutput/atlasViewer.mat') -%data = load('trials_markers'); -%times = output.output.dc.time; - -dc_HbO=dc.dataTimeSeries(:,1:3:length(dc.dataTimeSeries)); -dc_HbO(isnan(dc_HbO))=0; -save('timeseries_HbO.mat', 'dc_HbO') -dc_HbR=dc.dataTimeSeries(:,2:3:length(dc.dataTimeSeries)); -dc_HbR(isnan(dc_HbR))=0; -dc_HbR = dc_HbR; -save('timeseries_HbR.mat', 'dc_HbR') - -alpha = 1e-6; -tmp=size(Adot); -n_channels = tmp(1); -n_vert = tmp(2); -A= Adot(:,:,1); -tmp= sort(diag(A*A')); -loc_min = find(tmp>0.001); -lambda= tmp(loc_min(1)); -tmp= A'/(A*A'+lambda*eye(n_channels)); -save('transform_channel2vertice_HbO.mat', 'tmp') -A= Adot(:,:,2); -tmp= sort(eig(A*A'));%sort(diag(A*A')); -loc_min = find(tmp>0.001); -lambda= tmp(loc_min(1)); -tmp= A'/(A*A'+lambda*eye(n_channels)); -save('transform_channel2vertice_HbR.mat', 'tmp') - -end From c56baffb367fa5675c59668c3c830a01d8f65824 Mon Sep 17 00:00:00 2001 From: John Wang Date: Wed, 1 Dec 2021 13:23:56 -0500 Subject: [PATCH 6/6] update the inverse of sensitivity matrix --- kftools/homer/Homer_Atlas.m | 15 ++++++--------- 1 file changed, 6 insertions(+), 9 deletions(-) diff --git a/kftools/homer/Homer_Atlas.m b/kftools/homer/Homer_Atlas.m index 272b872..278025a 100644 --- a/kftools/homer/Homer_Atlas.m +++ b/kftools/homer/Homer_Atlas.m @@ -318,21 +318,18 @@ function SaveData(dc, Adot) dc_HbR = dc_HbR; save('timeseries_HbR.mat', 'dc_HbR') -alpha = 1e-6; +alpha = 0.5; tmp=size(Adot); n_channels = tmp(1); n_vert = tmp(2); A= Adot(:,:,1); -tmp= sort(diag(A*A')); -loc_min = find(tmp>0.001); -lambda= tmp(loc_min(1)); -tmp= A'/(A*A'+lambda*eye(n_channels)); + +lambda= alpha*min(eigs(A'*A)); +tmp= 1/(A'*A+lambda*eye(n_vert))*A'; save('transform_channel2vertice_HbO.mat', 'tmp') A= Adot(:,:,2); -tmp= sort(eig(A*A'));%sort(diag(A*A')); -loc_min = find(tmp>0.001); -lambda= tmp(loc_min(1)); -tmp= A'/(A*A'+lambda*eye(n_channels)); +lambda= alpha*min(eigs(A'*A)); +tmp= 1/(A'*A+lambda*eye(n_vert))*A'; save('transform_channel2vertice_HbR.mat', 'tmp') end