diff --git a/bin/CompileLEVer.m b/bin/CompileLEVer.m
new file mode 100644
index 0000000000000000000000000000000000000000..fec620633231ae59caa46b9169a4ae779d5c8c9c
--- /dev/null
+++ b/bin/CompileLEVer.m
@@ -0,0 +1 @@
+mcc -m ../LEVer.m
\ No newline at end of file
diff --git a/src/MATLAB/AddImagePixelsField.m b/src/MATLAB/AddImagePixelsField.m
index 37210f71d4cde67cd79c54b40ec19e42180646e2..09f333ab4faa9654c17b06a7a48c20becebf97a3 100644
--- a/src/MATLAB/AddImagePixelsField.m
+++ b/src/MATLAB/AddImagePixelsField.m
@@ -13,8 +13,12 @@ function AddImagePixelsField()
'imagePixels', cell(size(oldCellHulls)),...
'deleted', {oldCellHulls.deleted});
+ progress = 1;
+ iterations = length(HashedCells);
for t=1:length(HashedCells)
- imgfname = [CONSTANTS.rootImageFolder CONSTANTS.datasetName '_t' num2str(t,'%03d') '.TIF'];
+ progress = progress+1;
+ Progressbar(progress/iterations);
+ imgfname = [CONSTANTS.rootImageFolder CONSTANTS.datasetName '_t' SignificantDigits(t) '.TIF'];
[curimg map]=imread(imgfname);
curimg=mat2gray(curimg);
@@ -31,4 +35,5 @@ function AddImagePixelsField()
CellHulls(hullIdx(i)).imagePixels = curimg(CellHulls(hullIdx(i)).indexPixels);
end
end
+ Progressbar(1);%clear it out
end
\ No newline at end of file
diff --git a/src/MATLAB/AddNewSegmentHull.m b/src/MATLAB/AddNewSegmentHull.m
index 7130667d2a1f1463071c879e73e40cb261de34c2..2dbf5d14bdb8c499adfa1e8bd520dca674a7fd9b 100644
--- a/src/MATLAB/AddNewSegmentHull.m
+++ b/src/MATLAB/AddNewSegmentHull.m
@@ -1,14 +1,16 @@
function newTrackID = AddNewSegmentHull(clickPt)
- global CONSTANTS CellHulls CellFamilies Figures
+ global CONSTANTS CellHulls HashedCells Figures
fileName = [CONSTANTS.rootImageFolder CONSTANTS.datasetName '_t' num2str(Figures.time,'%03d') '.TIF'];
- [img colrMap] = imread(fileName);
+ [img colorMap] = imread(fileName);
img = mat2gray(img);
newObj = PartialImageSegment(img, clickPt, 200, 1.0);
newHull = struct('time', [], 'points', [], 'centerOfMass', [], 'indexPixels', [], 'imagePixels', [], 'deleted', 0);
+ oldTracks = [HashedCells{Figures.time}.trackID];
+
if ( isempty(newObj) )
% Add a point hull since we couldn't find a segmentation containing the click
newHull.time = Figures.time;
@@ -24,8 +26,11 @@ function newTrackID = AddNewSegmentHull(clickPt)
newHull.imagePixels = newObj.imagePixels;
end
- CellHulls(end+1) = newHull;
- newFamilyIDs = NewCellFamily(length(CellHulls), newHull.time);
+ newHullID = length(CellHulls)+1;
+ CellHulls(newHullID) = newHull;
+ newFamilyIDs = NewCellFamily(newHullID, newHull.time);
+
+ newTrackID = TrackSplitHulls(newHullID, oldTracks, newHull.centerOfMass);
- newTrackID = [CellFamilies(newFamilyIDs).rootTrackID];
+% newTrackID = [CellFamilies(newFamilyIDs).rootTrackID];
end
\ No newline at end of file
diff --git a/src/MATLAB/ConvertTrackingData.m b/src/MATLAB/ConvertTrackingData.m
index 60ddf24509f8224b0ae1592bb498681c97c20807..deb1d45628ad476311a39e035effa4acd3c932ac 100644
--- a/src/MATLAB/ConvertTrackingData.m
+++ b/src/MATLAB/ConvertTrackingData.m
@@ -4,20 +4,10 @@ function ConvertTrackingData(objHulls,gConnect)
%--Eric Wait
-global CONSTANTS Costs HashedCells CellHulls CellFamilies
+global CONSTANTS Costs CellHulls CellFamilies
-%Initialize CONSTANTS
CONSTANTS.imageSize = unique([objHulls(:).imSize]);
-CONSTANTS.maxPixelDistance = 40;
-CONSTANTS.maxCenterOfMassDistance = 80;
-CONSTANTS.minParentCandidateTimeFrame = 5;
-CONSTANTS.minParentHistoryTimeFrame = 5;
-CONSTANTS.minParentFuture = 5;
-CONSTANTS.minFamilyTimeFrame = 5;
-CONSTANTS.maxFrameDifference = 5;
-CONSTANTS.historySize = 50;
-CONSTANTS.clickMargin = 500;
-CONSTANTS.timeResolution = 10; %in frames per min
+
Costs = gConnect;
%Initialize Structures
@@ -30,13 +20,8 @@ cellHulls = struct(...
'imagePixels', {},...
'deleted', {});
-%loop through the data
-% progress = 1;
-% iterations = length(objHulls);
-% cellHulls(length(objHulls)) = ;
+%loop through the Hulls
parfor i=1:length(objHulls)
-% progress = progress+1;
-% Progressbar(progress/iterations);
cellHulls(i).time = objHulls(i).t;
cellHulls(i).points = objHulls(i).pts;
cellHulls(i).centerOfMass = objHulls(i).COM;
@@ -69,8 +54,13 @@ if(length(hullList)~=length(CellHulls))
NewCellFamily(reprocess(i),objHulls(reprocess(i)).t);
end
end
+Progressbar(1);%clear it out
-TestDataIntegrity(1);
+try
+ TestDataIntegrity(1);
+catch errormsg
+ fprintf('\n%s\n',errormsg.message);
+end
%create the family trees
ProcessNewborns(1:length(CellFamilies));
diff --git a/src/MATLAB/DrawCells.m b/src/MATLAB/DrawCells.m
index ed1401c1f86d065a2e87aaeced6a1b0ecf238725..8c8ca3869b06121f23728e6d3f8789476e7b1859 100644
--- a/src/MATLAB/DrawCells.m
+++ b/src/MATLAB/DrawCells.m
@@ -14,7 +14,7 @@ if(isempty(CellFamilies(Figures.tree.familyID).tracks)),return,end
figure(Figures.cells.handle);
set(Figures.cells.timeLabel,'String',['Time: ' num2str(Figures.time)]);
%read in image
-fileName = [CONSTANTS.rootImageFolder CONSTANTS.imageDatasetName '_t' num2str(Figures.time,'%03d') '.TIF'];
+fileName = [CONSTANTS.rootImageFolder CONSTANTS.datasetName '_t' SignificantDigits(Figures.time) '.TIF'];
[img colrMap] = imread(fileName);
xl=xlim;
yl=ylim;
diff --git a/src/MATLAB/GetDarkConnectedHulls.m b/src/MATLAB/GetDarkConnectedHulls.m
new file mode 100644
index 0000000000000000000000000000000000000000..6ffd5ffc07398c59867bde84929f299dbf079b42
--- /dev/null
+++ b/src/MATLAB/GetDarkConnectedHulls.m
@@ -0,0 +1,113 @@
+function objsSegment = GetDarkConnectedHulls(objsSegment)
+
+%--Andrew Cohen
+
+global CONSTANTS
+
+th=max([objsSegment.t]);
+
+fname=[CONSTANTS.rootImageFolder '\' CONSTANTS.datasetName '_t' SignificantDigits(1) '.TIF'];
+[im map]=imread(fname);
+HashedHulls=cell(th,1);
+
+for n=1:length(objsSegment)
+ objsSegment(n).imSize=size(im);
+ objsSegment(n).DarkConnectedHulls=[];
+ [r c]=ind2sub(objsSegment(n).imSize,objsSegment(n).indPixels);
+ objsSegment(n).COM=mean([r c],1);
+ HashedHulls{objsSegment(n).t}=[HashedHulls{objsSegment(n).t};n];
+end
+
+for t=1:th-1
+
+ if mod(t,20)==0
+ fprintf(1,[num2str(t) ', ']);
+ end
+ if mod(t,200)==0
+ fprintf(1,'\n');
+ end
+
+
+ objsSegment=GetDistances(objsSegment,HashedHulls,t,t+1);
+ if t<th-1
+ objsSegment=GetDistances(objsSegment,HashedHulls,t,t+2);
+ end
+end
+
+
+ function objsSegment=GetDistances(objsSegment,HashedHulls,t1,t2)
+ bwHalo1=GetHalo(t1);
+ bwHalo2=GetHalo(t2);
+ bwCombo=GetCombo(bwHalo1,bwHalo2,objsSegment,HashedHulls,t1,t2);
+ LCombo=bwlabel(bwCombo);
+ for i=1:length(HashedHulls{t1})
+ hi=HashedHulls{t1}(i);
+ ipix=objsSegment(hi).indPixels;
+ for j=1:length(HashedHulls{t2})
+ hj=HashedHulls{t2}(j);
+ dCOM=norm(objsSegment(hi).COM-objsSegment(hj).COM);
+ if dCOM>(t2-t1)*CONSTANTS.dMaxCenterOfMass
+ continue
+ end
+ jpix=objsSegment(hj).indPixels;
+ if ~isempty(intersect(ipix,jpix))
+ objsSegment(hi).DarkConnectedHulls=[objsSegment(hi).DarkConnectedHulls; hj 0];
+ else
+ if length(ipix)<length(jpix) % p1 smaller
+ p1=ipix;
+ p2=jpix;
+ else
+ p1=jpix;
+ p2=ipix;
+ end
+ [r1 c1]=ind2sub(objsSegment(hi).imSize,p1);
+ [r2 c2]=ind2sub(objsSegment(hj).imSize,p2);
+ dCCmin=Inf;
+ for k=1:length(r1)
+ dd=( (r2-r1(k)).^2+(c2-c1(k)).^2);
+ d=sqrt(min(dd));
+ if d<dCCmin
+ dCCmin=d;
+ end
+ if d<1
+ break
+ end
+ end
+ if 1==t2-t1
+ dmax=CONSTANTS.dMaxConnectComponet;
+ else
+ dmax=1.5*CONSTANTS.dMaxConnectComponet;
+ end
+ if dCCmin<dmax
+ objsSegment(hi).DarkConnectedHulls=[objsSegment(hi).DarkConnectedHulls; hj dCCmin];
+ end
+ end
+ end
+ end
+ end
+
+
+ function bwHalo=GetHalo(t)
+
+ fname=[CONSTANTS.rootImageFolder '\' CONSTANTS.datasetName '_t' SignificantDigits(t) '.TIF'];
+ [im map]=imread(fname);
+ im=mat2gray(im);
+
+
+ level=CONSTANTS.imageAlpha*graythresh(im);
+ bwHalo=im2bw(im,level);
+ end
+
+ function bwCombo=GetCombo(bwHalo1,bwHalo2,objsSegment,HashedHulls,t1,t2)
+
+ bwCombo=0*bwHalo1;
+ for i=1:length(HashedHulls{t1})
+ bwCombo(objsSegment(HashedHulls{t1}(i)).indTailPixels)=1;
+ end
+ for i=1:length(HashedHulls{t2})
+ bwCombo(objsSegment(HashedHulls{t2}(i)).indTailPixels)=1;
+ end
+ bwCombo(bwHalo1)=0;
+ bwCombo(bwHalo2)=0;
+ end
+end
\ No newline at end of file
diff --git a/src/MATLAB/InitializeConstants.m b/src/MATLAB/InitializeConstants.m
new file mode 100644
index 0000000000000000000000000000000000000000..e61181fa7eb5e6cdcef81520d82f11cc82058cc6
--- /dev/null
+++ b/src/MATLAB/InitializeConstants.m
@@ -0,0 +1,24 @@
+function InitializeConstants()
+%Set all constants here
+
+%--Eric Wait
+global CONSTANTS
+
+CONSTANTS.imageAlpha = 1;
+CONSTANTS.maxRetrackDistSq = 40^2;
+CONSTANTS.maxPixelDistance = 40;
+CONSTANTS.maxCenterOfMassDistance = 80;
+CONSTANTS.minParentCandidateTimeFrame = 5;
+CONSTANTS.minParentHistoryTimeFrame = 5;
+CONSTANTS.minParentFuture = 5;
+CONSTANTS.minFamilyTimeFrame = 5;
+CONSTANTS.maxFrameDifference = 5;
+CONSTANTS.historySize = 50;
+CONSTANTS.clickMargin = 500;
+CONSTANTS.timeResolution = 10; %in frames per min
+CONSTANTS.dMaxConnectComponet = 40;
+CONSTANTS.dMaxCenterOfMass = 80;
+CONSTANTS.lookAhead = 2;
+CONSTANTS.minPlayer = 9;
+CONSTANTS.minMitosis = 30;
+end
\ No newline at end of file
diff --git a/src/MATLAB/OpenData.m b/src/MATLAB/OpenData.m
index ca7354aa97e624eb90fbaeeb5fa5a4303fccc568..581d302a29a96bf1b770e6d48755d9081087c7a2 100644
--- a/src/MATLAB/OpenData.m
+++ b/src/MATLAB/OpenData.m
@@ -7,7 +7,7 @@ function opened = OpenData()
global Figures Colors CONSTANTS CellFamilies CellHulls HashedCells Costs CellTracks
if(isempty(Figures))
- fprintf('LEVer ver 3.7\n***DO NOT DISTRIBUTE***\n\n');
+ fprintf('LEVer ver 4.0\n***DO NOT DISTRIBUTE***\n\n');
end
if(exist('ColorScheme.mat','file'))
@@ -56,85 +56,119 @@ if(~isempty(Figures))
end
oldCONSTANTS = CONSTANTS;
-% .mat file handling
-while(~goodLoad)
- fprintf('Select .mat data file...\n');
- [matFile,matPath,filterIndexMatFile] = uigetfile([settings.matFilePath '*.mat'],...
- 'Open Data');
-
- if (filterIndexMatFile==0)
- return
- else
- fprintf('Opening file...');
- try
- %clear out globals so they can rewriten
- if(ishandle(Figures.cells.handle))
- close Figures.cells.handle
- end
- catch
- end
- CellFamilies = [];
- CellTracks = [];
- CellHulls = [];
- HashedCells = [];
- Costs = [];
- CONSTANTS = [];
- try
- load([matPath matFile]);
- fprintf('\nFile open.\n\n');
- catch exception
- %DEBUG -- Uncomment
- %disp(exception);
- end
- end
-
- if(exist('objHulls','var'))
- fprintf('Converting File...');
- ConvertTrackingData(objHulls,gConnect);
- fprintf('\nFile Converted.\n');
- CONSTANTS.datasetName = strtok(matFile,' ');
- save([matPath CONSTANTS.datasetName '_LEVer'],...
- 'CellFamilies','CellHulls','CellTracks','HashedCells','Costs','CONSTANTS');
- fprintf(['New file saved as:\n' CONSTANTS.datasetName '_LEVer.mat']);
- goodLoad = 1;
- elseif(exist('CellHulls','var'))
- goodLoad = 1;
- else
- errordlg('Data either did not load properly or is not the right format for LEVer.');
- goodLoad = 0;
- end
-end
%find the first image
-imageFilter = [settings.imagePath '*' CONSTANTS.datasetName '*.TIF'];
+imageFilter = [settings.imagePath '*.TIF'];
while (filterIndexImage==0)
fprintf('\nSelect first .TIF image...\n\n');
- [imageFile,imagePath,filterIndexImage] = uigetfile(imageFilter,['Open First Image in dataset: ' CONSTANTS.datasetName]);
+ [imageFile,imagePath,filterIndexImage] = uigetfile(imageFilter,'Open First Image in dataset: ');
if (filterIndexImage==0)
CONSTANTS = oldCONSTANTS;
return
end
end
-index = strfind(imageFile,'t');
+index = strfind(imageFile,'_t');
+frameT = '001';
if (~isempty(index) && filterIndexImage~=0)
CONSTANTS.rootImageFolder = imagePath;
- imageDataset = imageFile(1:(index(length(index))-2));
+ imageDataset = imageFile(1:(index(length(index))-1));
CONSTANTS.imageDatasetName = imageDataset;
- fileName=[CONSTANTS.rootImageFolder imageDataset '_t001.TIF'];
+ CONSTANTS.datasetName = imageDataset;
+ index2 = strfind(imageFile,'.');
+ CONSTANTS.imageSignificantDigits = index2 - index - 2;
+ fileName=[CONSTANTS.rootImageFolder imageDataset '_t' SignificantDigits(1) '.TIF'];
end
while (isempty(index) || ~exist(fileName,'file'))
- fprintf(['Image file name not in correct format: ' CONSTANTS.datasetName '_t001.TIF\nPlease choose another...\n']);
+ fprintf(['Image file name not in correct format: ' CONSTANTS.datasetName '_t' frameT '.TIF\nPlease choose another...\n']);
[imageFile,imagePath,filterIndexImage] = uigetfile(settings.imagePath,'Open First Image');
if(filterIndexImage==0)
CONSTANTS = oldCONSTANTS;
return
end
index = strfind(imageFile,'t');
- CONSTANTS.rootImageFolder = [imgPath '\'];
+ CONSTANTS.rootImageFolder = [imagePath '\'];
imageDataset = imageFile(1:(index(length(index))-2));
- fileName=[CONSTANTS.rootImageFolder imageDataSet '_t' num2str(t,'%03d') '.TIF'];
+ fileName=[CONSTANTS.rootImageFolder imageDataSet '_t' SignificantDigits(t) '.TIF'];
+end
+
+answer = questdlg('Run Segmentation and Tracking or Use Existing Data?','Data Source','Segment & Track','Existing','Existing');
+switch answer
+ case 'Segment & Track'
+ InitializeConstants();
+ SegAndTrack();
+ case 'Existing'
+ while(~goodLoad)
+ fprintf('Select .mat data file...\n');
+ [matFile,matPath,filterIndexMatFile] = uigetfile([settings.matFilePath '*.mat'],...
+ 'Open Data');
+
+ if (filterIndexMatFile==0)
+ return
+ else
+ fprintf('Opening file...');
+ try
+ %clear out globals so they can rewriten
+ if(ishandle(Figures.cells.handle))
+ close Figures.cells.handle
+ end
+ catch
+ end
+ CellFamilies = [];
+ CellTracks = [];
+ CellHulls = [];
+ HashedCells = [];
+ Costs = [];
+ rootImageFolder = CONSTANTS.rootImageFolder;
+ imageSignificantDigits = CONSTANTS.imageSignificantDigits;
+
+ try
+ load([matPath matFile]);
+ fprintf('\nFile open.\n\n');
+ catch exception
+ %DEBUG -- Uncomment
+ %disp(exception);
+ end
+ end
+
+ if(~isfield(CONSTANTS,'rootImageFolder'))
+ CONSTANTS.rootImageFolder = rootImageFolder;
+ end
+
+ if(~isfield(CONSTANTS,'imageSignificantDigits'))
+ CONSTANTS.imageSignificantDigits = imageSignificantDigits;
+ end
+
+ if(exist('objHulls','var'))
+ fprintf('Converting File...');
+ InitializeConstants();
+ ConvertTrackingData(objHulls,gConnect);
+ fprintf('\nFile Converted.\n');
+ CONSTANTS.datasetName = strtok(matFile,' ');
+ save([matPath CONSTANTS.datasetName '_LEVer'],...
+ 'CellFamilies','CellHulls','CellTracks','HashedCells','Costs','CONSTANTS');
+ fprintf(['New file saved as:\n' CONSTANTS.datasetName '_LEVer.mat']);
+ goodLoad = 1;
+ elseif(exist('CellHulls','var'))
+ goodLoad = 1;
+ else
+ errordlg('Data either did not load properly or is not the right format for LEVer.');
+ goodLoad = 0;
+ end
+ end
+
+ %save out settings
+ settings.matFilePath = matPath;
+ settings.imageFile = imageFile;
+ settings.imagePath = [imagePath '\'];
+ save('LEVerSettings.mat','settings');
+
+ Figures.time = 1;
+
+ LogAction(['Opened file ' matFile],[],[]);
+ otherwise
+ return
end
% Add imagePixels field to CellHulls structure (and resave in place)
@@ -148,22 +182,16 @@ end
opened = 1;
-%save out settings
-settings.matFilePath = matPath;
-settings.imageFile = imageFile;
-settings.imagePath = [imagePath '\'];
-save('LEVerSettings.mat','settings');
-
if (~strcmp(imageDataset,CONSTANTS.datasetName))
warndlg({'Image file name does not match .mat dataset name' '' 'LEVer may display cells incorectly!'},'Name mismatch','modal');
end
-if(~isempty(Figures) && ishandle(Figures.cells.handle))
- close(Figures.cells.handle);
-end
+% if(~isempty(Figures) && ishandle(Figures.cells.handle))
+% close(Figures.cells.handle);
+% end
-Figures.time = 1;
+% Figures.time = 1;
-LogAction(['Opened file ' matFile],[],[]);
+% LogAction(['Opened file ' matFile],[],[]);
end
diff --git a/src/MATLAB/PartialImageSegment.m b/src/MATLAB/PartialImageSegment.m
index 73838a4e6351f3c2f19193ab3e2bf33e56574fe8..e93ab3ec89fb709dcfcc575b479123ae59bbb49d 100644
--- a/src/MATLAB/PartialImageSegment.m
+++ b/src/MATLAB/PartialImageSegment.m
@@ -103,7 +103,7 @@ function hull = PartialImageSegment(img, centerPt, subSize, alpha)
HaloRat=length(find(p & bwHalo))/length(find(p));
- [r c]=ind2sub(imSize,pix);
+ [r c]=ind2sub(size(subImg),pix);
ch=convhull(r,c);
bwDarkInterior=bwDarkCenters&bwPoly;
@@ -159,7 +159,7 @@ function hull = PartialImageSegment(img, centerPt, subSize, alpha)
no.centerOfMass = mean([glr glc]);
%no.indPixels=pix;
- no.indexPixels = sub2ind(imSize,[glr glc]);
+ no.indexPixels = sub2ind(imSize, glr,glc);
no.imagePixels=img(no.indexPixels);
% surround completely by Halo?
if all(bwHaloHoles(pix))
@@ -204,7 +204,7 @@ function hull = PartialImageSegment(img, centerPt, subSize, alpha)
no.points=[glc(ch),glr(ch)];
no.centerOfMass = mean([glr glc]);
- no.indexPixels = sub2ind(imSize,[glr glc]);
+ no.indexPixels = sub2ind(imSize, glr,glc);
no.imagePixels=img(no.indexPixels);
no.ID=-1;
diff --git a/src/MATLAB/ReadTrackData.m b/src/MATLAB/ReadTrackData.m
new file mode 100644
index 0000000000000000000000000000000000000000..972214f1fbaba21fd68705b90aa25eb2de4716f1
--- /dev/null
+++ b/src/MATLAB/ReadTrackData.m
@@ -0,0 +1,71 @@
+function [objHulls gConnect HashedHulls]=ReadTrackData(objHulls,DatasetName)
+th=max([objHulls.t]);
+HashedHulls=cell(th,1);
+
+% reset tracking info
+for n=1:length(objHulls)
+ objHulls(n).Label=-1;
+ objHulls(n).inID=0;
+ objHulls(n).outID=0;
+ HashedHulls{objHulls(n).t}=[HashedHulls{objHulls(n).t};n];
+end
+fname=['.\Tracked_' DatasetName '.txt'];
+fid=fopen(fname,'r');
+bDone=0;
+TrackList=[];
+while ~bDone
+ dd=fscanf(fid,'%d,%d,%d,%d,%d\n',5);
+ if -1==dd(1)
+ bDone=1;
+ break
+ end
+ TrackList=[TrackList;dd'];
+end
+bDone=0;
+InList=[];
+while ~bDone
+ dd=fscanf(fid,'%d,%d,%f\n',3);
+ if isempty(dd)
+ bDone=1;
+ break
+ end
+ InList=[InList;dd'];
+end
+
+fclose(fid);
+for i=1:size(TrackList,1)
+ th=HashedHulls{TrackList(i,2)};
+ thk=HashedHulls{TrackList(i,3)};
+ o1=th(TrackList(i,4));
+ o2=thk(TrackList(i,5));
+ objHulls(o1).Label=TrackList(i,1);
+ objHulls(o2).Label=TrackList(i,1);
+ objHulls(o1).outID=o2;
+ objHulls(o2).inID=o1;
+end
+
+cmap=hsv(256);
+for i=1:max([objHulls.Label])
+ oi = find([objHulls.Label]==i);
+ ccc=cmap(round(255*rand())+1,:);
+ for j=1:length( oi)
+ objHulls(oi(j)).ccc=ccc;
+ end
+end
+nLabel=max([objHulls.Label])+1;
+for n=1:length(objHulls)
+ [r c]=ind2sub(objHulls(n).imSize,objHulls(n).indPixels);
+ objHulls(n).COM=mean([r c],1);
+ if objHulls(n).Label>0,continue,end
+ objHulls(n).Label= nLabel;
+ nLabel=nLabel+1;
+ ccc=cmap(round(255*rand())+1,:);
+ objHulls(n).ccc=ccc;
+end
+
+gConnect=sparse([],[],[],length(objHulls),length(objHulls),round(.1*length(objHulls)));
+for i=1:size(InList,1)
+ gConnect(InList(i,2),InList(i,1))=InList(i,3);
+end
+end
+
diff --git a/src/MATLAB/ResegmentEditedFamilies.m b/src/MATLAB/ResegmentEditedFamilies.m
index 082df3da6135a371b7934bcc465fece1c8802302..accd92b490f3043bfdd2da8e34c555fd5d4053ce 100644
--- a/src/MATLAB/ResegmentEditedFamilies.m
+++ b/src/MATLAB/ResegmentEditedFamilies.m
@@ -69,7 +69,7 @@ function [oldHulls oldIdx] = ResegmentEditedFamilies(families, hullCheckRadiusSq
continue;
end
- tmpgConnect = trackingCosts(hullsToTrack, t-1, avoidHulls, newHulls, newHash);
+ tmpgConnect = TrackingCosts(hullsToTrack, t-1, avoidHulls, newHulls, newHash);
nzCostIdx = find(tmpgConnect(hullsToTrack(1),:)>0);
diff --git a/src/MATLAB/SegAndTrack.m b/src/MATLAB/SegAndTrack.m
new file mode 100644
index 0000000000000000000000000000000000000000..e3f16b948f787f0a05c84c98933a82a89c18d1f7
--- /dev/null
+++ b/src/MATLAB/SegAndTrack.m
@@ -0,0 +1,76 @@
+function SegAndTrack()
+global CONSTANTS
+
+%% Segmentation
+tic
+
+fileList = dir([CONSTANTS.rootImageFolder CONSTANTS.imageDatasetName '*.tif']);
+numberOfImages = length(fileList);
+
+cellSegments = [];
+numProcessors = getenv('Number_of_processors');
+numProcessors = str2double(numProcessors);
+if(isempty(numProcessors) || isnan(numProcessors)),numProcessors = 2;end
+
+fprintf('Segmenting (using %s processors)...\n',num2str(numProcessors));
+
+step = ceil(numberOfImages/numProcessors);
+
+if(~isempty(dir('.\segmentationData')))
+ system('rmdir /S /Q .\segmentationData');
+end
+
+for timeStart=1:step:numberOfImages
+ system(['start Segmentor ' num2str(timeStart) ' ' num2str(step-1) ' "' ...
+ CONSTANTS.rootImageFolder(1:end-1) '" ' CONSTANTS.datasetName ' ' ...
+ num2str(CONSTANTS.imageAlpha) ' ' num2str(CONSTANTS.imageSignificantDigits) ' && exit']);
+end
+
+for i=1:step:numberOfImages
+ fileName = ['.\segmentationData\objs_' num2str(i) '.mat'];
+ fileDescriptor = dir(fileName);
+ while(isempty(fileDescriptor))
+ pause(1)
+ fileDescriptor = dir(fileName);
+ end
+ pause(2)
+end
+
+for i=1:step:numberOfImages
+ fileName = ['.\segmentationData\objs_' num2str(i) '.mat'];
+ load(fileName);
+ cellSegments = [cellSegments objs];
+ pause(1)
+end
+
+cellSegments = GetDarkConnectedHulls(cellSegments);
+save ( ['SegObjs_' CONSTANTS.datasetName '.mat'],'cellSegments');
+WriteSegData(cellSegments,CONSTANTS.datasetName);
+
+fprintf(1,'\nDone\n');
+
+load ( ['SegObjs_' CONSTANTS.datasetName '.mat']);
+fnameIn=['SegObjs_' CONSTANTS.datasetName '.txt'];
+fnameOut=['Tracked_' CONSTANTS.datasetName '.txt'];
+tSeg=toc;
+
+%% Tracking
+tic
+fprintf(1,'Tracking...');
+system(['.\MTC.exe ' fnameIn ' ' fnameOut ' > out.txt']);
+fprintf('Done\n');
+tTrack=toc;
+
+%% Inport into LEVer's data sturcture
+[objHulls gConnect HashedHulls] = ReadTrackData(cellSegments,CONSTANTS.datasetName);
+
+fprintf('Finalizing Data...');
+ConvertTrackingData(objHulls,gConnect);
+fprintf('Done\n');
+
+InitializeFigures();
+
+SaveDataAs();
+
+LogAction('Segmentation time - Tracking time',tSeg,tTrack);
+end
\ No newline at end of file
diff --git a/src/MATLAB/Segmentor.m b/src/MATLAB/Segmentor.m
new file mode 100644
index 0000000000000000000000000000000000000000..1e01b41543787e661a9acff7003856d7fe75f565
--- /dev/null
+++ b/src/MATLAB/Segmentor.m
@@ -0,0 +1,252 @@
+function objs = Segmentor(tStart,tLength,rootImageFolder,datasetName,imageAlpha,imageSignificantDigits)
+% Segmentor is to be run as a seperate compiled function for parallel
+% processing. It will process tLength-tStart amount of images. Call this
+% function for the number of processors on the machine.
+
+% mcc -o Segmentor -m Segmentor.m
+
+%--Andrew Cohen
+
+% global CONSTANTS
+se=strel('square',3);
+
+objs=[];
+if(ischar(tStart)),tStart = str2double(tStart);end
+if(ischar(tLength)),tLength = str2double(tLength);end
+if(ischar(imageAlpha)),imageAlpha = str2double(imageAlpha);end
+if(ischar(imageSignificantDigits)),imageSignificantDigits = str2double(imageSignificantDigits);end
+
+for t = tStart:tStart + tLength
+ switch imageSignificantDigits
+ case 3
+ frameT = num2str(t,'%03d');
+ case 4
+ frameT = num2str(t,'%04d');
+ case 5
+ frameT = num2str(t,'%05d');
+ case 6
+ frameT = num2str(t,'%06d');
+ end
+ fname=[rootImageFolder '\' datasetName '_t' frameT '.TIF'];
+ if(isempty(dir(fname))),continue,end
+
+ [im map]=imread(fname);
+ im=mat2gray(im);
+
+ bwDark=0*im;
+ level=imageAlpha*graythresh(im);
+ bwHalo=im2bw(im,level);
+
+ l2=graythresh(im);
+ pix=im(im<l2);
+ lDark=graythresh(pix);
+ bwDark(im<lDark)=1;
+
+ % bwNorm=GetNormalVectors(bwHalo,bwDark);
+ bwNorm=0*bwDark;
+
+ gd=imdilate(im,se);
+ ge=imerode(im,se);
+ ig=gd-ge;
+ lig=graythresh(ig);
+ bwig=im2bw(ig,lig);
+ seBig=strel('square',19);
+ bwmask=imclose(bwig,seBig);
+
+ bwDarkCenters=(bwDark & bwmask );
+ d=bwdist(~bwDarkCenters);
+ bwDarkCenters(d<2)=0;
+ %
+
+ bwHaloMask=imdilate(bwHalo,seBig);
+
+ bwHaloHoles=imfill(bwHalo ,8,'holes') & ~bwHalo;
+ bwDarkHoles=imfill(bwDarkCenters ,8,'holes') & ~bwDarkCenters;
+ bwgHoles=bwmorph(bwig | bwDarkCenters,'close',1) ;
+ bwgHoles=imfill( bwgHoles ,8,'holes') & ~(bwig |bwDarkCenters);
+
+ bwHoles=bwHaloHoles |bwDarkHoles|bwgHoles;
+
+ CC = bwconncomp(bwHoles,8);
+ LHoles = labelmatrix(CC);
+ stats = regionprops(CC, 'Area');
+ idx = find([stats.Area] < 500);
+ bwHoles = ismember(LHoles, idx);
+
+ % [r c]=find(bwHoles);
+ % plot(c,r,'.c');
+
+ bwCells=bwDarkCenters| bwHoles|bwNorm;
+ bwCells(~bwHaloMask)=0;
+
+
+ CC = bwconncomp(bwHalo,8);
+ LCells = labelmatrix(CC);
+
+ bwCells(bwig)=0;
+
+ % bwTails=imdilate(bwDarkCenters,strel('square',3));
+ bwTails=bwDarkCenters;
+ bwTails(bwHalo)=0;
+ CC = bwconncomp(bwTails,8);
+ LTails = labelmatrix(CC);
+
+ % hold off;imagesc(im);colormap(gray);hold on;
+ % title(num2str(t));
+ % [r c]=find(bwTails|bwCells);
+ % plot(c,r,'.g')
+
+ CC = bwconncomp(bwCells,8);
+ LCenters = labelmatrix(CC);
+ stats=regionprops(CC,'eccentricity');
+ d=bwdist(~bwCells);
+
+ num=max(LCenters(:));
+ for n=1:num
+ pix=find(LCenters==n);
+ if length(pix)<50
+ bwCells(pix)=0;
+ continue
+ end
+
+ % if length(find(bwDarkCenters(pix)))<1
+ % bwCells(pix)=0;
+ % continue
+ % end
+
+ bwPoly=logical(0*im);
+ bwPoly(pix)=1;
+ bwPoly=bwmorph(bwPoly,'dilate',1);
+ p=bwperim(bwPoly);
+
+
+ igRat=length(find(p & bwig))/length(find(p));
+
+ HaloRat=length(find(p & bwHalo))/length(find(p));
+
+ [r c]=ind2sub(size(im),pix);
+ ch=convhull(r,c);
+
+ bwDarkInterior=bwDarkCenters&bwPoly;
+ DarkRat=length(find(bwDarkInterior))/length(find(bwPoly));
+ % fprintf(1,'%d, %2.3f, %2.3f, %2.3f %d\n',n ,igRat, DarkRat,HaloRat,length(pix));
+ if HaloRat>0.5 || igRat<.1 ||(DarkRat<.5 && igRat<.5 && length(pix)<175)
+ % plot(c(ch),r(ch),'-y')
+ bwCells(pix)=0;
+ continue
+ end
+ dmax=max(d(pix));
+ if dmax>4
+ bwCells(pix(d(pix)<2))=0;
+ % bwCells(pix(find(d(pix)<2)))=0;
+ end
+
+ end
+
+
+ bwCellFG=0*bwCells;
+
+ CC = bwconncomp(bwCells,8);
+ LCenters = labelmatrix(CC);
+ stats=regionprops(CC,'area','Eccentricity');
+ idx = find([stats.Area] >=25);
+ for i=1:length(idx)
+ pix=find(LCenters==idx(i));
+ if length(pix)<20
+ continue
+ end
+ [r c]=ind2sub(size(im),pix);
+ bwPoly=roipoly(im,c,r);
+ if bwarea(bwPoly)<1
+ continue
+ end
+
+ ch=convhull(r,c);
+ % one last check for parasites
+ if length(find(im(pix)>lDark))/length(pix)> 0.5
+ % plot(c(ch),r(ch),'-c')
+ continue
+ end
+ % it's a keeper!
+ bwCellFG(pix)=1;
+
+
+
+ % plot(c(ch),r(ch),'-r','linewidth',1.5)
+
+ no=[];
+ no.t=t;
+ no.pts=[c(ch),r(ch)];
+
+ no.indPixels=pix;
+ if LTails(r(1),c(1))
+ TailPix = find(LTails==LTails(r(1),c(1)));
+ TailPix=union(TailPix,pix);
+ else
+ TailPix=pix;
+ end
+ no.indTailPixels=TailPix;
+ no.imPixels=im(pix);
+ % surround completely by Halo?
+ if all(bwHaloHoles(pix))
+ no.BrightInterior=1;
+ else
+ no.BrightInterior=0;
+ end
+ no.ID=-1;
+ no.Eccentricity=stats(idx(i)).Eccentricity;
+ objs=[objs no];
+ % drawnow
+
+
+ end
+
+ % bright interiors
+ igm=bwig|bwHalo;
+ se=strel('square',5);
+ igm=imclose(igm,se);
+ igm=imfill(igm,'holes');
+ igm(logical(bwCellFG))=0;
+ se=strel('square',13);
+ igm=imerode(igm,se);
+
+ CC = bwconncomp(igm,8);
+ Ligm = labelmatrix(CC);
+ stats = regionprops(CC, 'Area','Eccentricity');
+ idx = find( [stats.Area] >25 & [stats.Area] <1000 & [stats.Eccentricity]<.95 ) ;
+
+ for i=1:length(idx)
+ pix=find(Ligm==idx(i));
+ [r c]=ind2sub(size(im),pix);
+ ch=convhull(r,c);
+
+ bwPoly = poly2mask(c(ch),r(ch),size(im,1),size(im,2));
+ if ~isempty(find(bwCellFG &bwPoly, 1)),continue,end
+ no=[];
+ no.t=t;
+ no.pts=[c(ch),r(ch)];
+ no.ID=-1;
+
+ no.indPixels=pix;
+ if LTails(r(1),c(1))
+ TailPix = find(LTails==LTails(r(1),c(1)));
+ TailPix=union(TailPix,pix);
+ else
+ TailPix=pix;
+ end
+ no.indTailPixels=TailPix;
+ no.BrightInterior=1;
+ no.Eccentricity=stats(idx(i)).Eccentricity;
+ no.imPixels=im(pix);
+ objs=[objs no];
+
+ % plot(c(ch),r(ch),'-m')
+ % plot(c(ch),r(ch),'-r','linewidth',1.5)
+ % drawnow
+ end
+end
+
+fileName = ['.\segmentationData\objs_' num2str(tStart) '.mat'];
+if(isempty(dir('.\segmentationData'))),system('mkdir .\segmentationData');end
+save(fileName,'objs');
+end
\ No newline at end of file
diff --git a/src/MATLAB/SignificantDigits.m b/src/MATLAB/SignificantDigits.m
new file mode 100644
index 0000000000000000000000000000000000000000..0df525d2f60c938286b1891e0d16dff14043881b
--- /dev/null
+++ b/src/MATLAB/SignificantDigits.m
@@ -0,0 +1,19 @@
+function digits = SignificantDigits(num)
+% SignificantDigits will see how many digits the image file name needs for
+% each frame and then will convert num to the appropriate string
+
+%--Eric Wait
+
+global CONSTANTS
+digits = '';
+switch CONSTANTS.imageSignificantDigits
+ case 3
+ digits = num2str(num,'%03d');
+ case 4
+ digits = num2str(num,'%04d');
+ case 5
+ digits = num2str(num,'%05d');
+ case 6
+ digits = num2str(num,'%06d');
+end
+end
\ No newline at end of file
diff --git a/src/MATLAB/SplitHull.m b/src/MATLAB/SplitHull.m
index 1d01f1aa269bfe2dae916da674dbcb5c080e026b..6893630d97bc770b3046c1aed0ab7d4635577f28 100644
--- a/src/MATLAB/SplitHull.m
+++ b/src/MATLAB/SplitHull.m
@@ -4,7 +4,10 @@ function newTrackIDs = SplitHull(hullID, k)
%--Mark Winter
-global CellHulls CellFamilies
+global CellHulls CellFamilies HashedCells
+
+oldCOM = CellHulls(hullID).centerOfMass;
+oldTracks = [HashedCells{CellHulls(hullID).time}.trackID];
newHulls = ResegmentHull(CellHulls(hullID), k);
@@ -15,12 +18,16 @@ end
% Just arbitrarily assign clone's hull for now
CellHulls(hullID) = newHulls(1);
+newHullIDs = hullID;
% Other hulls are just added off the clone
newFamilyIDs = [];
for i=2:length(newHulls)
CellHulls(end+1) = newHulls(i);
newFamilyIDs = [newFamilyIDs NewCellFamily(length(CellHulls), newHulls(i).time)];
+ newHullIDs = [newHullIDs length(CellHulls)];
end
-newTrackIDs = [CellFamilies(newFamilyIDs).rootTrackID];
+% newTrackIDs = [CellFamilies(newFamilyIDs).rootTrackID];
+
+newTrackIDs = TrackSplitHulls(newHullIDs, oldTracks, oldCOM);
end
diff --git a/src/MATLAB/TestDataIntegrity.m b/src/MATLAB/TestDataIntegrity.m
index 67be371fbd778656dbf43859c22cb1aa2dc00ab2..1f0aedd462df638667e8bf76a96d9cc1cd7573d7 100644
--- a/src/MATLAB/TestDataIntegrity.m
+++ b/src/MATLAB/TestDataIntegrity.m
@@ -117,21 +117,22 @@ end
%% check CellHulls
% if(length(hullsList)~=length(find([CellHulls.deleted]==0)))
missingHulls = find(ismember(find([CellHulls.deleted]==0),hullsList')==0);
-if(~isempty(missingHulls))
- if(correct)
- progress = 0;
- iterations = length(missingHulls);
- for i=1:length(missingHulls)
- progress = progress+1;
- Progressbar(progress/iterations);
- if(isempty(CellHulls(missingHulls(i)).points))
- CellHulls(missingHulls(i)).deleted = 1;
- end
- end
- else
- error('HullsList ~= CellHulls');
- end
-end
+% if(~isempty(missingHulls))
+% if(correct)
+% progress = 0;
+% iterations = length(missingHulls);
+% for i=1:length(missingHulls)
+% progress = progress+1;
+% Progressbar(progress/iterations);
+% if(isempty(CellHulls(missingHulls(i)).points))
+% CellHulls(missingHulls(i)).deleted = 1;
+% end
+% end
+% else
+% error('HullsList ~= CellHulls');
+% end
+% end
+Progressbar(1);%clear it out
fprintf('\nDone\n');
end
diff --git a/src/MATLAB/TrackSplitHulls.m b/src/MATLAB/TrackSplitHulls.m
new file mode 100644
index 0000000000000000000000000000000000000000..8a6471d808daebb3edd1b28ca51905e6ce64d473
--- /dev/null
+++ b/src/MATLAB/TrackSplitHulls.m
@@ -0,0 +1,148 @@
+function trackIDs = TrackSplitHulls(newHulls, forceTracks, COM)
+ global CONSTANTS CellHulls HashedCells
+
+ t = CellHulls(newHulls(1)).time;
+ if ( t <= 1 )
+ return;
+ end
+
+ curHulls = [HashedCells{t}.hullID];
+% curTracks = [HashedCells{t}.trackID];
+ lastHulls = [HashedCells{t-1}.hullID];
+ distSq = sum((vertcat(CellHulls(lastHulls).centerOfMass) - ones(length(lastHulls),1)*COM).^2, 2);
+
+ bTrackHull = distSq < CONSTANTS.maxRetrackDistSq;
+ trackHulls = lastHulls(bTrackHull);
+
+ if ( isempty(trackHulls) )
+ return;
+ end
+
+ oldTracks = [HashedCells{t-1}(bTrackHull).trackID];
+
+% % TODO: don't muck up edited tracks (labels)
+% for i=1:length(oldTracks)
+% hashTime = t - CellTracks(oldTracks(i)).startTime + 1;
+% if ( length(CellTracks(oldTracks(i)).hulls) >= hashTime )
+% CellTracks(oldTracks(i)).hulls(hashTime) = 0;
+% end
+% end
+
+ avoidHulls = setdiff(curHulls,newHulls);
+ tmpGConnect = TrackingCosts(trackHulls, t-1, avoidHulls, CellHulls, HashedCells);
+
+ [r c] = ndgrid(trackHulls, curHulls);
+ costIdx = sub2ind(size(tmpGConnect), r, c);
+ costMatrix = tmpGConnect(costIdx);
+
+ bAffected = any(costMatrix,1);
+ affectedHulls = curHulls(bAffected);
+ costMatrix = costMatrix(:,bAffected);
+
+ bOutTracked = any(costMatrix,2);
+% trackHulls = trackHulls(bOutTracked);
+ extendTracks = oldTracks(bOutTracked);
+ costMatrix = full(costMatrix(bOutTracked,:));
+
+ costMatrix(costMatrix == 0) = Inf;
+
+% % Dump unaffected tracks from the force-keep list
+% affectedTracks = curTracks(bAffected);
+% forceTracks = intersect(forceTracks, union(oldTracks,affectedTracks));
+
+ assignTracks(t, costMatrix, extendTracks, affectedHulls);
+
+ trackIDs = [HashedCells{t}(ismember([HashedCells{t}.hullID],newHulls)).trackID];
+end
+
+function assignTracks(t, costMatrix, extendTracks, affectedHulls)
+% bMustAssign = ismember(oldTracks, forceTracks);
+% bDontChange = ismember(affectedTracks, setdiff(forceTracks,oldTracks));
+%
+% % Remove columns representing assignments which will remove a
+% % force-keep track
+% affectedHulls = affectedHulls(~bDontChange);
+% costMatrix = costMatrix(:,~bDontChange);
+
+ [minInCosts,bestIncoming] = min(costMatrix,[],1);
+ [minOutCosts,bestOutgoing] = min(costMatrix,[],2);
+
+ bestOutgoing = bestOutgoing';
+ bMatchedCol = false(size(bestIncoming));
+ bMatched = (bestIncoming(bestOutgoing) == (1:length(bestOutgoing)));
+ bMatchedCol(bestOutgoing(bMatched)) = 1;
+ matchedIdx = find(bMatched);
+
+ % Assign matched edges
+ for i=1:length(matchedIdx)
+ assignHull = affectedHulls(bestOutgoing(matchedIdx(i)));
+ assignTrack = extendTracks(matchedIdx(i));
+
+ assignHullToTrack(t, assignHull, assignTrack);
+ end
+
+ costMatrix(bMatched,:) = Inf;
+ costMatrix(:,bMatchedCol) = Inf;
+
+ [minCost minIdx] = min(costMatrix(:));
+ % Patch up whatever other tracks we can
+ while( ~isinf(minCost) )
+ [r c] = ind2sub(size(costMatrix), minIdx);
+ assignHull = affectedHulls(c);
+ assignTrack = extendTracks(r);
+
+ assignHullToTrack(t, assignHull, assignTrack);
+
+ costMatrix(r,:) = Inf;
+ costMatrix(:,c) = Inf;
+
+ [minCost minIdx] = min(costMatrix(:));
+ end
+end
+
+function assignHullToTrack(t, hull, track)
+ global HashedCells
+
+ oldHull = [];
+
+ % Get old hull - track assignments
+ bOldHull = [HashedCells{t}.trackID] == track;
+ if ( any(bOldHull) )
+ oldHull = HashedCells{t}(bOldHull).hullID;
+ end
+
+ oldTrack = HashedCells{t}([HashedCells{t}.hullID] == hull).trackID;
+
+ % Hull - track assignment is unchanged
+ if ( oldHull == hull )
+ return;
+ end
+
+ if ( ~isempty(oldHull) )
+ % Swap track assignments
+ swapTracking(t, oldHull, hull, track, oldTrack);
+ else
+ % Add hull to track
+ AddHullToTrack(hull, track, []);
+ end
+end
+
+% Currently hullA has trackA, hullB has trackB
+% swap so that hullA gets trackB and hullB gets trackA
+function swapTracking(t, hullA, hullB, trackA, trackB)
+ global HashedCells CellTracks
+
+ hashAIdx = ([HashedCells{t}.hullID] == hullA);
+ hashBIdx = ([HashedCells{t}.hullID] == hullB);
+
+ % Swap track IDs
+ HashedCells{t}(hashAIdx).trackID = trackB;
+ HashedCells{t}(hashBIdx).trackID = trackA;
+
+ % Swap hulls in tracks
+ hashTime = t - CellTracks(trackA).startTime + 1;
+ CellTracks(trackA).hulls(hashTime) = hullB;
+
+ hashTime = t - CellTracks(trackB).startTime + 1;
+ CellTracks(trackB).hulls(hashTime) = hullA;
+end
diff --git a/src/MATLAB/WriteSegData.m b/src/MATLAB/WriteSegData.m
new file mode 100644
index 0000000000000000000000000000000000000000..fd44da274aa968e35701d19199c36bf22c7b2ade
--- /dev/null
+++ b/src/MATLAB/WriteSegData.m
@@ -0,0 +1,28 @@
+function WriteSegData(objsSegment,DatasetName)
+sz=[1024 1344];
+th=max([objsSegment.t]);
+HashedHulls=cell(th,1);
+
+% reset tracking info
+for n=1:length(objsSegment)
+ HashedHulls{objsSegment(n).t}=[HashedHulls{objsSegment(n).t};n];
+end
+fname=['SegObjs_' DatasetName '.txt'];
+fid=fopen(fname,'wt');
+fprintf(fid,'%d %d\n',th,length(objsSegment) );
+for i=1:length(HashedHulls)
+ fprintf(fid,'%d\n',length(HashedHulls{i}) );
+ for j=1:length(HashedHulls{i})
+ [r c]=ind2sub(sz,objsSegment(HashedHulls{i}(j)).indPixels);
+ COM=round(mean([r c],1));
+ %i,t,xCOM,yCOM
+ fprintf(fid,'%d %d %d %d:',COM(2),COM(1),length(r),size(objsSegment(HashedHulls{i}(j)).DarkConnectedHulls,1) );
+ for k=1:size(objsSegment(HashedHulls{i}(j)).DarkConnectedHulls,1)
+ fprintf(fid,' %d,%f', objsSegment(HashedHulls{i}(j)).DarkConnectedHulls(k,1),objsSegment(HashedHulls{i}(j)).DarkConnectedHulls(k,2));
+ end
+ fprintf(fid,'\n');
+ end
+end
+
+fclose(fid);
+end
\ No newline at end of file
diff --git a/src/MATLAB/constrainedBestPath.m b/src/MATLAB/constrainedBestPath.m
index a7da7e8593c3e3403c03872ef978901fb12f58ae..e4e45105face8ebca6e5cc0a37d3370a6cff6933 100644
--- a/src/MATLAB/constrainedBestPath.m
+++ b/src/MATLAB/constrainedBestPath.m
@@ -1,5 +1,4 @@
function [gConnect, allPathsCosts] = constrainedBestPath(hullIdx, tStart, tEnd, constraints, hulls, hash, gConnect)
- scriptConstants
global CONSTANTS
windowSize = tEnd - tStart;
@@ -32,11 +31,11 @@ function [gConnect, allPathsCosts] = constrainedBestPath(hullIdx, tStart, tEnd,
thGlobal = [thHistory thPath];
if 105==tStart
- dmax_cc=3*DMAX_CC;
- dmax_com=3*DMAX_COM;
+ dmax_cc=3*CONSTANTS.dMaxConnectComponet;
+ dmax_com=3*CONSTANTS.dMaxCenterOfMass;
else
- dmax_cc=DMAX_CC;
- dmax_com=DMAX_COM;
+ dmax_cc=CONSTANTS.dMaxConnectComponet;
+ dmax_com=CONSTANTS.dMaxCenterOfMass;
end
LocalCost = HullDist(hulls, thPath(1), thPath(2), dmax_cc, dmax_com);
diff --git a/src/MATLAB/constrainedDFS.m b/src/MATLAB/constrainedDFS.m
index 2db31ea86b2db4048fdfd53c0b2886b1c95b261e..52e26bafa8892b6efcd70a9c5ac4cf085b87b6de 100644
--- a/src/MATLAB/constrainedDFS.m
+++ b/src/MATLAB/constrainedDFS.m
@@ -1,5 +1,5 @@
function [path allPaths] = constrainedDFS(hullIdx, constraints, hulls, hash, t0, t1, path, allPaths)
- scriptConstants;
+ global CONSTANTS
curCnsts = [];
bFoundPath = 0;
@@ -9,11 +9,11 @@ function [path allPaths] = constrainedDFS(hullIdx, constraints, hulls, hash, t0,
curCnsts = constraints{length(path)};
for i=1:length(curCnsts)
if 105==t0
- dmax_cc=3*DMAX_CC;
- dmax_com=3*DMAX_COM;
+ dmax_cc=3*CONSTANTS.dMaxConnectComponet;
+ dmax_com=3*CONSTANTS.dMaxCenterOfMass;
else
- dmax_cc=DMAX_CC;
- dmax_com=DMAX_COM;
+ dmax_cc=CONSTANTS.dMaxConnectComponet;
+ dmax_com=CONSTANTS.dMaxCenterOfMass;
end
[d dSz] = HullDist(hulls, hullIdx, curCnsts(i), dmax_cc, dmax_com);
diff --git a/src/MATLAB/scriptConstants.m b/src/MATLAB/scriptConstants.m
deleted file mode 100644
index 57ed9033d4743f37afac01278d6501e48a9639ef..0000000000000000000000000000000000000000
--- a/src/MATLAB/scriptConstants.m
+++ /dev/null
@@ -1,11 +0,0 @@
-% CONSTANTS
-
-DMAX_CC=40; %
-DMAX_COM=80; %
-
-LOOKAHEAD=2;
-
-% min lifetime to participate in split / merge, also anyone younger than
-% this chooses after old folks at assignment
-MIN_PLAYER=9;
-MIN_MITOSIS=30;
\ No newline at end of file
diff --git a/src/MATLAB/trackingCosts.m b/src/MATLAB/trackingCosts.m
index 8efa98110f7498f42f36cdb4c470659a0388a7a0..a34bb04dff2b0c8c5522d21744a292d8d6f25465 100644
--- a/src/MATLAB/trackingCosts.m
+++ b/src/MATLAB/trackingCosts.m
@@ -1,5 +1,5 @@
-function gConnect = trackingCosts(trackHulls, t, avoidHulls, hulls, hash)
- windowSize = 4;
+function gConnect = TrackingCosts(trackHulls, t, avoidHulls, hulls, hash)
+ windowSize = 2;
gConnect = sparse([],[],[],length(hulls),length(hulls),round(0.1*length(hulls)));
if ( t+1 > length(hash) )