Upload folder using huggingface_hub

SUN_source_code_v1/README.txt

@@ -0,0 +1,54 @@
+This software is available for only non-commercial use.  See the attached license in LICENSE.txt under code/scene_sun folder.
+
+This is a post-CVPR version of the code and may produce slightly different (hopefully better) results than the performance reported in the following paper:
+
+J. Xiao, J. Hays, K. Ehinger, A. Oliva, and A. Torralba
+SUN Database: Large-scale Scene Recognition from Abbey to Zoo
+Proceedings of 23rd IEEE Conference on Computer Vision and Pattern Recognition (CVPR2010) 
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+
+USAGE
+
+There are two top level folders in this zip file: code and data. All source code goes to code folder, and all data goes to code folder. Our source code is located under the folder code/scene_sun. To ease the deployment of the software, we also include the libraries from other research groups in this package under different folders under code folder. Please read their respective compilation and installation instructions as well as software license in their respective folders. Folder data/vocabulary contain k-means clustered codebook for bag-of-word features. We don't provide codes to generate this codebook but it should be straightforward to compute it using our feature extraction code and k-mean in MATLAB toolbox. Although it is possible to put image data and intermediate results in a separate folder, we recommend you to put them inside data/dataset_name .
+
+Step 1: Download and uncompress the image data to the folder data/scene_15class/image or data/scene_397class/image depends on which database you use.
+You can download the 15 scene categories dataset from:
+http://www-cvr.ai.uiuc.edu/ponce_grp/data/index.html#scenes
+and the SUN 397 class dataset from 
+http://groups.csail.mit.edu/vision/SUN/
+In the folder data/scene_15class and data/scene_397class, we have contained MAT file split10.mat for random training and testng data split that we used for the paper.
+
+Step 2: You need to change the folder path in compute_feature.m and run_kernel_svm.m to select which database for you to use.
+
+Step 3: Run compute_feature.m to compute the image features. You can use more than one MATLAB sessions to run this scripts at the same time parallelly.
+
+Step 4: Run run_kernel_svm.m to train SVM and do evaluation.
+
+Notice: This code is not optimized for speed. It may takes a long time to compute the result. Please use a fast computer and be patient. We suggest you run the code on the 15-scene dataset for debugging purpose to make sure this code works correctly first, before you run on the SUN 397 database. For the 15 scene database, if you run the code correctly, you should be able to get the following result report for the combined kernel approach.
+combine kernel accuracy (normalized)   = 88.4 <- this is slightly better than what we report in the CVPR paper.
+combine kernel accuracy (unnormalized) = 79.2
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+
+ENVIRONMENT
+
+We only tested our code in CSAIL Debian Linux on 64bit Intel Machine with 32GB memory, and Matlab Version 7.7.0.471 (R2008b).
+But it should be quite straightforward to port the code into Windows or Mac.
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+
+BUG REPORT
+
+Please email to jxiao@csail.mit.edu for reporting any bug. We can only provide minimal support for academic researchers only.
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+
+REFERENCES
+
+This code implements the following papers.  Note that the implementation may not be exact.
+Please cite this paper if you use the code in your research.
+
+J. Xiao, J. Hays, K. Ehinger, A. Oliva, and A. Torralba
+SUN Database: Large-scale Scene Recognition from Abbey to Zoo
+Proceedings of 23rd IEEE Conference on Computer Vision and Pattern Recognition (CVPR2010) 

SUN_source_code_v1/code/GeometricContext_dhoiem/LICENSE.txt

@@ -0,0 +1,15 @@
+License for Non-Commercial Use
+
+If this software is redistributed, this license must be included. The term software includes any 
+source files, documentation, executables, models, and data.
+
+This software is available for general use by academic or non-profit, or government-sponsored 
+researchers.  It may also be used for evaluation purposes elsewhere.  This license does not grant 
+the right to use this software or any derivation of it in a for-profit enterprise.  For 
+commercial use, please contact the Tech Transfer Office at Carnegie Mellon University.  
+
+This software comes with no warranty or guarantee of any kind.  By using this software, the user
+accepts full liability.
+
+This license is written by Derek Hoiem (C) 2010.
+

SUN_source_code_v1/code/GeometricContext_dhoiem/README

@@ -0,0 +1,127 @@
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+SOURCE README FOR AUTOMATIC PHOTO POPUP AND GEOMETRIC CONTEXT 
+Derek Hoiem (dhoiem@cs.cmu.edu)
+01/08/2010
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+
+
+LICENSE
+
+Copyright (C) 2007 Derek Hoiem, Carnegie Mellon University
+
+This software is available for only non-commercial use.  See the attached
+license in LICENSE.txt.  
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+
+
+REFERENCES
+
+This code implements the following papers.  Note that the implementation may not be exact.
+Please cite one or more of these papers, depending on the use.
+
+D. Hoiem, A.A. Efros, and M. Hebert, "Geometric Context from a Single Image", ICCV 2005.
+
+D. Hoiem, A.A. Efros, and M. Hebert, "Recovering Surface Layout from an Image", IJCV, Vol. 75, No. 1, 
+October 2007.
+
+D. Hoiem, A.A. Efros, and M. Hebert, "Automatic Photo Pop-up", ACM SIGGRAPH 2005.
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+
+
+Note about VERSIONS
+
+This contains two versions of the "Automatic Photo Pop-up" and "Geometric 
+"Context" code.  The first version is from the SIGGRAPH 2005 / ICCV 2005 papers
+and involves the functions photoPopup and APPtestImage.  The second version
+is from the IJCV 2007 paper and involves the functions photoPopupIjcv and 
+ijcvTestImage.  Note that these implementations may not be exact.  In particular,
+some changes to features were made to improve speed, which may have small effects
+on accuracy.  Further, the multiple segmentation algorithm is random, so different
+runs will not produce identical results.
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+
+
+How to RUN:
+
+
+First, appropriately replace the path for the segment command in im2superpixels.m.
+
+Geometric Context version 1 (ICCV 2005):
+  [labels, conf_map, maps, pmaps] = APPtestImage(image, imsegs, vClassifier, hClassifier, segDensity)
+      image should be a double color image
+      imsegs is the superpixel structure (if empty, will be computed)
+      The remaining three arguments are stored in data/classifiers_08_22_2005.mat 
+  
+  [labels, conf_map, imsegs] = ...
+    APPtestDirectory(segDensity, vClassifier, hClassifier, imdir, imfn, varargin)
+      Processes a directory of images with given filenames.  Optional last argument is where to 
+      store displayed results.
+
+
+Geometric Context version 2 (IJCV 2007):
+  [pg, data, imsegs] = ijcvTestImage(im, imsegs, classifiers, smaps, spdata, adjlist, edata);
+      The only required fields are im and classifiers.  
+      Example usage: 
+         load '../data/ijcvClassifier.mat'
+
+
+         classifiers=load('../data/ijcvClassifier_indoor.mat');
+         [pg, data, imsegs] = ijcvTestImage(im, [], classifiers);
+         [cimages, cnames] = pg2confidenceImages(imsegs, {pg});
+         % only keep ground pourous sky vertical [1 5 7 8]
+         geom_c_map = cimages{1}(:,:,[1 5 7 8]);
+
+
+
+      Classifiers trained on indoor and outdoor images are provided in the data directory.
+  
+  [pg, smaps, imsegs] = ijcvTestImageList(fn, imsegs, classifiers, laboutdir, confoutdir)
+      Processes all images whose names are given in fn.  As above, imsegs can be empty.
+
+
+Automatic Photo Pop-up (SIGGRAPH 2005, IJCV 2007)
+  photoPopup(fnData, fnImage, extSuperpixelImage, outdir)
+    This is the 2005 version.
+    fnData is the filename containing the classifiers (data/classifiers_08_22_2005.mat).
+    If extSuperpixelImage is empty, it will be computed.
+    
+  photoPopupIjcv(fnData, fnImage, extSuperpixelImage, outdir)
+    This is the IJCV 2007 version.  See notes above.
+
+
+Training:
+  For the IJCV version, see src/ijcv06/ijcvMultiSegScript.m
+  This function performs both training and evaluation.  It requires some edits.  It is currently
+  setup for cross-validation, but it should be straightforward to use separate train and test sets.
+  The Geometric Context Dataset (separate download) contains rand_indices which specifies the 
+  train/test splits.
+
+  
+Other useful functions:
+   src/util/splitpg.m
+   src/util/pg2confidenceImages.m
+   src/util/pg2*
+   src/util/write*
+   
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+
+NOTES:
+
+  Superpixels:
+  I use the segmentation code provided by Felzenszwalb and Huttenlocher
+  at people.cs.uchicago.edu/~pff/segment/ to create the superpixels in my
+  experiments.  The first three arguments (sigma, k, min) that I use are 
+  0.8 100 100.  I've included a pl script for segmenting a directory
+  that you may find useful.  You can also use a different program to create 
+  the superpixel image.  That image should have a different RGB color for 
+  each segment without drawn boundaries between segments.  
+
+
+(C) Derek Hoiem, Carnegie Mellon University, 2007
+ 

SUN_source_code_v1/code/GeometricContext_dhoiem/data/classifiers_08_22_2005.mat

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:4e16bc17ce09bb357c0ffd8c4c47f90b31a5091e03595dbab5287ea222185649
+size 231989

SUN_source_code_v1/code/GeometricContext_dhoiem/data/ijcvClassifier.mat

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:2ba29f94013c150396eedb80a5e0db656a96f754ca82fbbde02995979882d93b
+size 460724

SUN_source_code_v1/code/GeometricContext_dhoiem/data/ijcvClassifier_indoor.mat

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:3300ce7eba2e4bcd2e732babb3f139eb5d6c2e023c70c41a4cb9e2dc193a9ea4
+size 198126

SUN_source_code_v1/code/GeometricContext_dhoiem/src/APPtestDirectory.m

@@ -0,0 +1,88 @@
+function [labels, conf_map, imsegs] = ...
+    APPtestDirectory(segDensity, vClassifier, hClassifier, ...
+        imdir, imfn, varargin)
+% [labels, conf_map] = APPtestDirectory(segDensity, vClassifier,
+%                                   hClassifier, imdir, imsegs, varargin)
+%
+% Gets the geometry for each image with superpixels given by imsegs.
+%
+% Input:
+%   segDensity: structure giving probability of 2 sp having same label
+%   vClassifier: segment classifier for ground/vert/sky
+%   hClassifier: segment classifier for subclassses of vert
+%   imdir: the image directory 
+%   imfn: the image filenames
+%   varargin{1} (optional): the output directory for displaying results
+% Output:
+%   labels: structure containing labeling results for each image
+%   conf_map: the likelihoods for each sp for each class for each image
+%
+% Copyright(C) Derek Hoiem, Carnegie Mellon University, 2005
+% Current Version: 1.0  09/30/2005
+
+DO_PARALLEL = 0; % for running multiple parallel processes on directory
+
+if length(varargin) > 0
+    outdir = varargin{1};
+end
+
+for f = 1:length(imfn)
+           
+    fn = imfn{f}; 
+    bn = strtok(fn, '.');  
+    
+    if ~DO_PARALLEL || ~exist(outdir) || ~exist([outdir '/' bn '.c.mat'])
+        
+        if ~exist(outdir, 'file')
+           mkdir(outdir);
+        end
+
+        if DO_PARALLEL % to mark as being processed
+            touch([outdir '/' bn '.c.mat']);
+        end        
+            
+        image = im2double(imread([imdir, '/', fn]));
+        
+        tmp = im2superpixels(image);
+        tmp.imname = fn;
+        imsegs(f) = tmp;
+
+        if size(image, 3) == 3 
+
+            disp(['processing image ' fn]);
+
+            [labels(f), conf_map(f), maps{f}, pmaps(f)] = ...
+                    APPtestImage(image, imsegs(f), vClassifier, hClassifier, segDensity);               
+            % for generating context
+            [cimages, cnames] = APPclassifierOutput2confidenceImages(imsegs(f), conf_map(f));
+
+            if length(varargin) > 0
+                outdir = varargin{1};
+
+                limage = APPgetLabeledImage(image, imsegs(f), labels(f).vert_labels, labels(f).vert_conf, ...
+                    labels(f).horz_labels, labels(f).horz_conf);          
+                imwrite(limage, [outdir, '/', bn, '.l.jpg']);
+                imwrite(image, [outdir, '/', fn]);
+
+                % for generating context
+                glabels = labels(f);
+                gconf_map = conf_map(f);
+                gmaps = maps{f};
+                gpmaps = pmaps(f);
+                save([outdir '/' bn '.c.mat'], 'glabels', 'gconf_map', 'cimages', 'cnames', 'gmaps', 'gpmaps', 'imsegs');
+
+                % make a vrml file
+                APPwriteVrmlModel(imdir, imsegs(f), labels(f), outdir);    
+            end
+
+        end
+
+	drawnow;
+
+    end
+    
+end
+
+for f = 1:length(imfn)
+    labels(f).imname = imsegs(f).imname;
+end

SUN_source_code_v1/code/GeometricContext_dhoiem/src/APPtestImage.m

@@ -0,0 +1,138 @@
+function [labels, conf_map, maps, pmaps] = APPtestImage(image, imsegs, ...
+    vClassifier, hClassifier, segDensity)
+% [labels, conf_map, maps, pmaps] = APPtestImage(image, imsegs,
+%                                  vClassifier, hClassifier, segDensity)
+% 
+% Gets the geometry for a single image.
+%
+% Input:
+%   image: the image to process
+%   imsegs: the sp structure
+%   vClassifier: region classifier for main classes
+%   hClassifier: region classifier for vertical subclasses
+%   segDensity: density for superpixel clustering
+% Output:
+%   labels: structure containing labeling results for each image
+%   conf_map: the likelihoods for each sp for each class for each image
+%   maps: the segmentation region maps (from superpixels to regions)
+%   pmaps: probabilities for each region
+%
+% Copyright(C) Derek Hoiem, Carnegie Mellon University, 2005
+% Current Version: 1.0  09/30/2005
+
+
+% mix class must be the last class in each classifier
+
+if isempty(imsegs)
+  imsegs = im2superpixels(image);
+end
+
+%exclude mix class
+nvclasses = length(vClassifier.names)-1; 
+nhclasses = length(hClassifier.names)-1;
+
+[doog_filters, texton_data] = APPgetImageFilters;
+
+imsegs.seginds = APPgetSpInds(imsegs);
+
+% compute features
+spdata = APPgetSpData(image, doog_filters, texton_data.tim, imsegs);
+[spdata.hue, spdata.sat, tmp] = rgb2hsv(image);
+
+
+imsize = size(image);
+minEdgeLen = sqrt(imsize(1)^2+imsize(2)^2)*0.02;
+[vpdata.lines, vpdata.spinfo] = ...
+    APPgetLargeConnectedEdges(rgb2gray(image), minEdgeLen, imsegs);
+[vpdata.v, vpdata.vars, vpdata.p, vpdata.hpos] = ...
+    APPestimateVp(vpdata.lines, imsize(1:2), 0);
+
+% create multiple partitions
+num_partitions = [3 4 5 7 9 11 15 20 25];
+num_maps = length(num_partitions);
+maps = APPsp2regions(segDensity, spdata, num_partitions);                
+
+nsegs = imsegs.nseg;
+pV = zeros(nsegs, nvclasses);
+pH = zeros(nsegs, nhclasses);
+
+% compute the probability of each block having each possible label
+for m = 1:num_maps
+    
+    currMap = maps(:, m);  
+    
+    %cluster_image = get_cluster_overlay_s2(rgb2gray(image), currMap, imsegs.segimage);                                
+    %imwrite(cluster_image, ['../results/tmp/alley09.c.' num2str(max(currMap)) '.jpg'], 'Quality', 80);    
+    
+    currNSegments = max(currMap(:));
+    
+    regionFeatures = APPgetRegionFeatures(image, imsegs, currMap, (1:currNSegments), spdata, vpdata);    
+       
+    nregions = size(regionFeatures, 1);
+
+    % get probability of vertical classes P(y|x) for each region
+    tmpV = test_boosted_dt_mc(vClassifier, regionFeatures);
+    tmpV = 1 ./ (1+exp(-tmpV));    
+    
+    % get probability of horizontal classes P(y|x) for each region
+    tmpH = test_boosted_dt_mc(hClassifier, regionFeatures);  
+    tmpH = 1 ./ (1+exp(-tmpH));
+    
+    % normalize probabilities so that each is P(label|~mixed)P(~mixed)
+    % normalize probabilities and sum over maps
+    for r = 1:nregions
+        indices = find(currMap == r);  
+        tmpV(r, 1:end-1) = tmpV(r, 1:end-1) / sum(tmpV(r, 1:end-1));
+        tmpV(r, 1:end-1) = tmpV(r, 1:end-1) * (1-tmpV(r, end));
+        for c = 1:nvclasses        
+            pV(indices, c) = pV(indices, c) + tmpV(r, c);%*pYv(c, r);
+        end
+        tmpH(r, 1:end-1) = tmpH(r, 1:end-1) / sum(tmpH(r, 1:end-1));
+        tmpH(r, 1:end-1) = tmpH(r, 1:end-1) * (1-tmpH(r, end));
+        for c = 1:nhclasses       
+            pH(indices, c) = pH(indices, c) + tmpH(r, c);%*pYh(c, r);
+        end
+                                    
+    end
+
+    pmaps.v{m} = tmpV;
+    pmaps.h{m} = tmpH;
+    
+end
+
+% re-normalize weighted vote from classifiers
+for s = 1:size(pV, 1)
+    pV(s, :) = pV(s, :) / sum(pV(s, :));
+end
+for s = 1:size(pH, 1)
+    pH(s, :) = pH(s, :) / sum(pH(s, :));
+end
+
+conf_map.vmap = pV;
+conf_map.hmap = pH;
+conf_map.vnames = vClassifier.names(1:end-1);
+conf_map.hnames = hClassifier.names(1:end-1);
+
+
+% get label for each block with confidence
+% total_labels = char(zeros(num_blocks, 7));
+labels.vert_labels = cell(nsegs, 1);
+labels.vert_conf = zeros(nsegs, 1);
+labels.horz_labels = cell(nsegs, 1);
+labels.horz_conf = zeros(nsegs, 1);
+for s = 1:nsegs
+    [labels.vert_conf(s), c] = max(pV(s, :));
+    labels.vert_labels(s) = vClassifier.names(c);
+    [labels.horz_conf(s), c] = max(pH(s, :));
+    labels.horz_labels(s) = hClassifier.names(c);        
+end
+
+[tmp, vlabels] = max(pV, [], 2);
+[tmp, hlabels] = max(pH, [], 2);
+
+if 0 
+[hy, estType] = geometry2horizon(imsegs, vlabels, hlabels, vpdata);
+
+labels.hy = 1-hy;
+labels.hestType = estType;
+end

SUN_source_code_v1/code/GeometricContext_dhoiem/src/boosting/test_boosted_dt_mc.m

@@ -0,0 +1,42 @@
+function confidences = test_boosted_dt_mc(classifier, features)
+% confidences = test_boosted_dt_mc(classifier, features)
+%
+% Returns a log likelihod ratio for each class in the classifier    
+% 
+% Input:
+%  classifier: boosted decision tree classifier
+%  features:   classifier features (ndata, nvariables)
+% Output:
+%   confidences(ndata, nclasses): 
+%      P(class=k|features) \propto 1./(1+exp(-confidences(k)))
+
+npred = classifier.wcs(1).dt.npred;
+if size(features, 2)~=npred
+    error('Incorrect number of attributes')
+end
+
+wcs = classifier.wcs;  
+nclasses = size(wcs, 2);
+
+ntrees = size(wcs, 1);
+
+confidences = zeros(size(features, 1), nclasses);
+for c = 1:nclasses    
+    for t = 1:ntrees        
+        if ~isempty(wcs(t,c).dt)                                              
+            if 1
+                dt = wcs(t,c).dt; 
+                [var, cut, children, catsplit] = tree_getParameters(dt);
+                nodes = treevalc(int32(var), cut, int32(children(:, 1)), ...
+                        int32(children(:, 2)), catsplit(:, 1), features');  
+                %disp(num2str(nodes));      
+            else
+                [class_indices, nodes, classes] = treeval(wcs(t, c).dt, features);             
+            end
+            confidences(:, c) = confidences(:, c) + wcs(t, c).confidences(nodes);
+        end        
+    end
+    confidences(:, c) = confidences(:, c) + classifier.h0(c);
+end
+
+   

SUN_source_code_v1/code/GeometricContext_dhoiem/src/boosting/test_boosted_kde_2c.m

@@ -0,0 +1,12 @@
+function p = test_boosted_kde_2c(density, x, data)
+% used to evaluate the likelihood of a point from a kernel density estimate
+% density is the density function
+% x are the points at which f is defined (assumed to be equally spaced)
+% data are the data points to be evaluated
+% p is the value of f(xi) where x(xi) is the closest value in x to y
+
+n = length(x);
+wx = x(2)-x(1);
+indices = round((data- x(1))/wx)+1;
+indices = min(max(indices, 1), n);
+p = density(indices);

SUN_source_code_v1/code/GeometricContext_dhoiem/src/boosting/train_boosted_dt_2c.m

@@ -0,0 +1,90 @@
+function classifier = train_boosted_dt_2c(features, cat_features, ...
+    labels, num_iterations, nodespertree, stopval, w)
+% classifier = train_boosted_dt_2c(features, cat_features, ...
+%    labels, num_iterations, nodespertree, stopval, w)
+%
+% Trains a two-class classifier based on boosted decision trees.  Boosting done by the
+% logistic regression version of Adaboost (Adaboost.L - Collins, Schapire,
+% Singer 2002).  At each iteration, a set of decision trees is created, with
+% confidences equal to 1/2*ln(P+/P-), according to the
+% weighted distribution.  Weights are assigned as
+% w(i,j) = 1 / (1+exp(sum{t in iterations}[yij*ht(xi, j)])).  
+% features(ndata, nfeatures)
+% cat_features - discrete-valued output feature indices (could be [])
+% labels - {-1, 1}
+% num_iterations - the number of trees to create
+
+
+num_data = length(labels);
+
+cl = [-1 1];
+y = labels;
+
+if ~exist('stopval', 'var') || isempty(stopval)
+    stopval = 0;
+end
+
+if ~exist('w', 'var') || isempty(w)
+    w = ones(num_data, 1);
+end
+w = w/sum(w);
+
+classifier.h0 = 0;
+
+% for i = 1:2
+%     indices = find(y==cl(i));
+%     count = numel(indices);
+%     if cl(i)==1
+%         classifier.h0 = log(count / (num_data-count));
+%     end
+%     w(indices) = 1 / count/2;
+% end    
+
+data_confidences = zeros(num_data, 1);
+aveconf = [];
+
+for t = 1:num_iterations
+    % learn decision tree based on weighted distribution
+    dt = treefitw(features, y, w, 1/num_data/2, 'catidx', cat_features, 'method', 'classification', 'maxnodes', nodespertree*4);
+    [tmp, level] = min(abs(dt.ntermnodes-nodespertree));
+    dt = treeprune(dt, 'level', level-1);
+    % assign partition confidences
+    pi = (strcmp(dt.classname{1},'1')) + (2*strcmp(dt.classname{2},'1'));
+    ni = (strcmp(dt.classname{1},'-1')) + (2*strcmp(dt.classname{2},'-1'));
+    classprob = dt.classprob;
+    confidences = 1/2*(log(classprob(:, pi)) - log(classprob(:, ni)));             
+
+    % assign weights
+    [class_indices, nodes, classes] = treeval(dt, features);        
+    data_confidences = data_confidences + confidences(nodes);
+    w = 1 ./ (1+exp(y.*data_confidences));        
+    w = w / sum(w);
+           
+    pconf = mean(1./(1+exp(-data_confidences(y==1))));
+    nconf = mean(1./(1+exp(-data_confidences(y==-1))));
+    
+    disp(['c: ' num2str(mean(1 ./ (1+exp(-y.*data_confidences)))) '  e: ' ...
+        num2str(mean(y.*data_confidences < 0)) '  c_p: ' num2str(pconf) '  c_n: ' num2str(nconf)]);  
+    
+    classifier.wcs(t,1).dt = dt;
+    classifier.wcs(t,1).confidences = confidences;       
+    %pause(0.1);
+    
+    aveconf(t) = mean(1 ./ (1+exp(-y.*data_confidences)));
+    if t>10 && (aveconf(t)-aveconf(t-10) < stopval)
+        disp(num2str(aveconf))        
+        disp(['Stopping after ' num2str(t) ' trees'])
+        break;
+    end    
+    
+end
+
+disp(['mean conf = ' num2str(mean(1 ./ (1+exp(-y.*data_confidences))))]);
+disp(['training error: ' num2str(mean(y.*data_confidences < 0))]);    
+
+
+
+
+
+
+        

SUN_source_code_v1/code/GeometricContext_dhoiem/src/boosting/train_boosted_dt_mc.m

@@ -0,0 +1,154 @@
+function classifier = train_boosted_dt_mc(features, cat_features, labels, ...
+    num_iterations, num_nodes, stopval, init_weights, varargin)
+%
+%classifier = train_boosted_dt_mc(features, cat_features, labels, ...
+%    num_iterations, num_nodes, stopval, init_weights, varargin)
+%
+% Train a classifier based on boosted decision trees.  Boosting done by the
+% logistic regression version of Adaboost (Adaboost.L - Collins, Schapire,
+% Singer 2002).  At each
+% iteration, a set of decision trees is created for each class, with
+% confidences equal to 1/2*ln(P+/P-) for that class, according to the
+% weighted distribution.  Final classification is based on the largest
+% confidence label (possibly incorporating a prior as h0(c) =
+% 1/2*ln(Pc/(1-Pc)).  Weights are assigned as
+% w(i,j) = 1 / (1+exp(sum{t in iterations}[yij*ht(xi, j)])).  
+
+if length(varargin) == 1  % class names supplied
+    gn = varargin{1};
+    gid = zeros(size(labels));
+    for c = 1:length(gn)
+        ind = find(strcmp(labels, gn{c}));
+        gid(ind) = c;
+        if ~isempty(init_weights)
+            disp([gn{c} ': ' num2str(sum(init_weights(ind)))]);
+        else
+            disp([gn{c} ': ' num2str(length(ind))]);
+        end
+    end
+    ind = find(gid==0);
+    gid(ind) = [];
+    labels(ind) = [];
+    features(ind, :) = [];
+else    
+    [gid, gn] = grp2idx(labels);    
+end
+
+if ~exist('stopval', 'var') || isempty(stopval)
+    stopval = 0;
+end
+if ~exist('init_weights', 'var') 
+    init_weights = [];
+end
+
+classifier.names = gn;
+
+num_classes = length(gn);
+num_data = length(gid);
+
+if isempty(init_weights)
+    init_weights = ones(num_data, 1)/num_data;
+else
+    init_weights = init_weights / sum(init_weights);
+end
+
+% if no examples from a class are present, create one dummy example for
+% that class with very small weight
+for c = 1:numel(gn)
+    if ~any(gid==c)
+        disp(['warning: no examples from class ' gn(c)])
+        gid(end+1) = c;
+        features(end+1, :) = zeros(size(features(end, 1)));
+        num_data = num_data + 1;
+        init_weights(end+1) = min(init_weights)/2;        
+    end
+end
+
+all_conf = zeros(num_data, num_classes);
+for c = 1:num_classes
+
+    disp(['class: ' num2str(gn{c})]);    
+    y = (gid == c)*2-1;
+    cl = [-1 1];
+    nc = 2;
+    w = zeros(num_data, 1);
+    cw = zeros(num_classes, 1);  
+    for i = 1:2
+        indices = find(y==cl(i));
+        %count = sum(init_weights(indices));
+        %w(indices) = init_weights(indices) / count / 2;
+        w(indices) = init_weights(indices);
+        
+        if cl(i)==1
+            %classifier.h0(c) = log(count / (1-count));
+            classifier.h0(c) = 0;
+        end
+        
+    end
+        
+    data_confidences = zeros(num_data, 1);
+    aveconf = [];
+    
+    for t = 1:num_iterations
+        % learn decision tree based on weighted distribution
+        dt = treefitw(features, y, w, 1/num_data/2, 'catidx', cat_features, 'method', 'classification', 'maxnodes', num_nodes*4);
+        [tmp, level] = min(abs(dt.ntermnodes-num_nodes));
+        dt = treeprune(dt, 'level', level-1);
+
+        % assign partition confidences
+        pi = (strcmp(dt.classname{1},'1')) + (2*strcmp(dt.classname{2},'1'));
+        ni = (strcmp(dt.classname{1},'-1')) + (2*strcmp(dt.classname{2},'-1'));
+        
+        classprob = dt.classprob;
+        confidences = 1/2*(log(classprob(:, pi)) - log(classprob(:, ni)));             
+
+        % assign weights
+        [class_indices, nodes, classes] = treeval(dt, features);        
+        data_confidences = data_confidences + confidences(nodes);
+        
+        w = 1 ./ (1+exp(y.*data_confidences));        
+        w = w / sum(w);   
+                
+        %disp(['c: ' num2str(mean(1 ./ (1+exp(-y.*data_confidences)))) '  e: ' num2str(mean(y.*data_confidences < 0)) '   w: ' num2str(max(w))]);  
+        
+        classifier.wcs(t, c).dt = dt;
+        classifier.wcs(t, c).confidences = confidences;       
+             
+        
+        aveconf(t) = mean(1 ./ (1+exp(-y.*data_confidences)));
+        if t>10 && (aveconf(t)-aveconf(t-10) < stopval)
+            disp(num2str(aveconf))
+            disp(['Stopping after ' num2str(t) ' trees'])            
+            break;
+        end
+        
+    end
+
+    finalconf = 1 ./ (1+exp(-y.*data_confidences));
+    finalerr = (y.*data_confidences < 0);
+    disp(['confidence:: mean: ' num2str(mean(finalconf)) ...
+        '  pos: ' num2str(mean(finalconf(y==1))) ...
+        '  neg: ' num2str(mean(finalconf(y~=1)))]);
+    disp(['training error:: mean: ' num2str(mean(finalerr)) ...
+        '  pos: ' num2str(mean(finalerr(y==1))) ...
+        '  neg: ' num2str(mean(finalerr(y~=1)))]);    
+    all_conf(:, c) = data_confidences+classifier.h0(c);
+  
+end
+
+% compute and display training error
+[tmp, assigned_label] = max(all_conf, [], 2);
+conf_matrix = zeros(num_classes, num_classes);
+for c = 1:num_classes    
+    indices = find(gid==c);
+    for c2 = 1:num_classes
+        conf_matrix(c, c2) = mean(assigned_label(indices)==c2);
+    end
+    disp([gn{c} ' error: ' num2str(mean(assigned_label(indices)~=c))]);
+end
+disp('Confusion Matrix: ');
+disp(num2str(conf_matrix));
+disp(['total error: ' num2str(mean(assigned_label~=gid))]);
+
+
+        

SUN_source_code_v1/code/GeometricContext_dhoiem/src/boosting/train_boosted_kde_2c.m

@@ -0,0 +1,112 @@
+function density = train_boosted_kde_2c(data, labels, ranges, num_iter)
+% Try to learn ln(P(x1, x2 | +)/P(x1, x2 | -), where + indicates that a pair of points,
+% x, are in the same cluster and - indicates that the pair are in different
+% clusters.  Use boosting to estimate the parameters of the density in a
+% naive structure.
+% density(num_features).{x, log_ratio}
+
+
+ndata = numel(labels);
+nfeatures = size(data, 2);
+
+if ~exist('ranges') || isempty(ranges)
+    ranges = cell(nfeatures, 1);
+end
+    
+for f = 1:numel(ranges)
+    if isempty(ranges{f})
+        ranges{f} = 'unbounded';
+    end
+end
+
+pos_indices = find(labels==1);
+neg_indices = find(labels==-1);
+npos = length(pos_indices);
+nneg = length(neg_indices);
+%weights = 1/num_data*ones(num_data, 1);
+% weights = zeros(ndata, 1);
+% weights(pos_indices) = 1/2/npos;
+% weights(neg_indices) = 1/2/nneg;
+weights = repmat(1/ndata, [ndata 1]);
+pos_data = data(pos_indices, :);
+neg_data = data(neg_indices, :);
+
+kernel_width = zeros(nfeatures, 1);
+
+% get optimal kernel width and xrange
+% this window parameter is recommended by Silverman(1986) for non-normal plots
+for f = 1:nfeatures
+         
+    y = data(:, f);
+    s = std(y);
+    sorty = sort(y);
+    n = length(y);
+    iq = sorty(round(3/4*n))-sorty(round(n/4));
+    density(f).kernelwidth = 0.9*min(s, iq/1.34)*(1/n)^(1/5); 
+    %disp(num2str(density(f).kernelwidth))
+    [tmp, density(f).x] = ksdensity(y, 'weights', weights, ...
+        'width', density(f).kernelwidth, 'support', ranges{f});
+    density(f).log_ratio = zeros(size(density(f).x));
+end
+
+total_confidences = zeros(ndata, 1);
+for m = 1:num_iter
+    pos_weights = weights(pos_indices);
+    neg_weights = weights(neg_indices);
+    tmp_confidences = zeros(ndata, 1);
+    % update densities
+    for f = 1:nfeatures       
+        pos_f = ksdensity(pos_data(:, f), density(f).x, 'weights', pos_weights, ...
+            'width', density(f).kernelwidth, 'support', ranges{f});
+        pos_f = pos_f + 1/(ndata/2);
+        pos_f = pos_f / sum(pos_f) * sum(pos_weights);        
+        neg_f = ksdensity(neg_data(:, f), density(f).x, 'weights', neg_weights, ...
+            'width', density(f).kernelwidth, 'support', ranges{f});       
+        neg_f = neg_f + 1/(ndata/2);
+        neg_f = neg_f / sum(neg_f) * sum(neg_weights);        
+                                
+        tmp_ratio = (log(pos_f)-log(neg_f));
+        %density(f).log_ratio = density(f).log_ratio + tmp_ratio;
+        curr_ratio(f).log_ratio = tmp_ratio;
+        tmp_confidences = tmp_confidences + ...
+            test_boosted_kde_2c(tmp_ratio, density(f).x, data(:, f))';
+    end
+    
+    % get alpha parameter for confidence
+    alpha = fminbnd(@compute_expected_confidence, 0.001, 2.0, [], labels, tmp_confidences, weights); 
+    %disp(['alpha = ' num2str(alpha)]);
+    for f = 1:nfeatures
+        density(f).log_ratio = density(f).log_ratio + alpha*curr_ratio(f).log_ratio;
+    end
+    
+    weights = weights .* exp(-alpha*tmp_confidences.*labels);
+    sumw = sum(weights);
+    %disp(['sum w = ' num2str(sumw)]);
+    weights = weights / sumw;
+    
+    total_confidences = total_confidences + alpha*tmp_confidences;
+    
+    disp(['training error:  n_err = ' num2str(mean(total_confidences(neg_indices)>=0)) ' p_err = ' ...
+            num2str(mean(total_confidences(pos_indices)<0))]);    
+    if 0    
+    [f1, x] = ksdensity(total_confidences(pos_indices));
+    f2 = ksdensity(total_confidences(neg_indices), x);
+    figure(1), plot(x, f1, 'b', x, f2, 'r');    
+    pause(0.5);
+    end
+
+end
+
+
+
+
+function expected_confidence = compute_expected_confidence(alpha, labels, confidences, weights)        
+% used to choose alpha
+% alpha is chosen so that the expected confidence:
+% E(weight*exp(-alpha*label*confidence)*label*confidence) = 0
+% Note: Absolute value used so that minimization results in best confidence
+% confidence.  Normalization is unnecesary for finding alpha, though.
+new_weights = exp(-alpha*labels.*confidences).*weights;    
+expected_confidence = sum(new_weights);
+%expected_confidence = abs(sum(new_weights.*labels.*confidences)/sum(new_weights));
+    

SUN_source_code_v1/code/GeometricContext_dhoiem/src/boosting/train_boosted_stubs_mc.m

@@ -0,0 +1,154 @@
+function classifier = train_boosted_dt_mc(features, cat_features, labels, ...
+    num_iterations, num_nodes, stopval, init_weights, varargin)
+%
+%classifier = train_boosted_dt_mc(features, cat_features, labels, ...
+%    num_iterations, num_nodes, stopval, init_weights, varargin)
+%
+% Train a classifier based on boosted decision trees.  Boosting done by the
+% logistic regression version of Adaboost (Adaboost.L - Collins, Schapire,
+% Singer 2002).  At each
+% iteration, a set of decision trees is created for each class, with
+% confidences equal to 1/2*ln(P+/P-) for that class, according to the
+% weighted distribution.  Final classification is based on the largest
+% confidence label (possibly incorporating a prior as h0(c) =
+% 1/2*ln(Pc/(1-Pc)).  Weights are assigned as
+% w(i,j) = 1 / (1+exp(sum{t in iterations}[yij*ht(xi, j)])).  
+
+if length(varargin) == 1  % class names supplied
+    gn = varargin{1};
+    gid = zeros(size(labels));
+    for c = 1:length(gn)
+        ind = find(strcmp(labels, gn{c}));
+        gid(ind) = c;
+        if ~isempty(init_weights)
+            disp([gn{c} ': ' num2str(sum(init_weights(ind)))]);
+        else
+            disp([gn{c} ': ' num2str(length(ind))]);
+        end
+    end
+    ind = find(gid==0);
+    gid(ind) = [];
+    labels(ind) = [];
+    features(ind, :) = [];
+else    
+    [gid, gn] = grp2idx(labels);    
+end
+
+if ~exist('stopval', 'var') || isempty(stopval)
+    stopval = 0;
+end
+if ~exist('init_weights', 'var') 
+    init_weights = [];
+end
+
+classifier.names = gn;
+
+num_classes = length(gn);
+num_data = length(gid);
+
+if isempty(init_weights)
+    init_weights = ones(num_data, 1)/num_data;
+else
+    init_weights = init_weights / sum(init_weights);
+end
+
+% if no examples from a class are present, create one dummy example for
+% that class with very small weight
+for c = 1:numel(gn)
+    if ~any(gid==c)
+        disp(['warning: no examples from class ' gn(c)])
+        gid(end+1) = c;
+        features(end+1, :) = zeros(size(features(end, 1)));
+        num_data = num_data + 1;
+        init_weights(end+1) = min(init_weights)/2;        
+    end
+end
+
+all_conf = zeros(num_data, num_classes);
+for c = 1:num_classes
+
+    disp(['class: ' num2str(gn{c})]);    
+    y = (gid == c)*2-1;
+    cl = [-1 1];
+    nc = 2;
+    w = zeros(num_data, 1);
+    cw = zeros(num_classes, 1);  
+    for i = 1:2
+        indices = find(y==cl(i));
+        %count = sum(init_weights(indices));
+        %w(indices) = init_weights(indices) / count / 2;
+        w(indices) = init_weights(indices);
+        
+        if cl(i)==1
+            %classifier.h0(c) = log(count / (1-count));
+            classifier.h0(c) = 0;
+        end
+        
+    end
+        
+    data_confidences = zeros(num_data, 1);
+    aveconf = [];
+    
+    for t = 1:num_iterations
+        % learn decision tree based on weighted distribution
+        dt = treefitw(features, y, w, 1/num_data/2, 'catidx', cat_features, 'method', 'classification', 'maxnodes', num_nodes*4);
+        [tmp, level] = min(abs(dt.ntermnodes-num_nodes));
+        dt = treeprune(dt, 'level', level-1);
+
+        % assign partition confidences
+        pi = (strcmp(dt.classname{1},'1')) + (2*strcmp(dt.classname{2},'1'));
+        ni = (strcmp(dt.classname{1},'-1')) + (2*strcmp(dt.classname{2},'-1'));
+        
+        classprob = dt.classprob;
+        confidences = 1/2*(log(classprob(:, pi)) - log(classprob(:, ni)));             
+
+        % assign weights
+        [class_indices, nodes, classes] = treeval(dt, features);        
+        data_confidences = data_confidences + confidences(nodes);
+        
+        w = 1 ./ (1+exp(y.*data_confidences));        
+        w = w / sum(w);   
+                
+        disp(['c: ' num2str(mean(1 ./ (1+exp(-y.*data_confidences)))) '  e: ' num2str(mean(y.*data_confidences < 0)) '   w: ' num2str(max(w))]);  
+        
+        classifier.wcs(t, c).dt = dt;
+        classifier.wcs(t, c).confidences = confidences;       
+             
+        
+        aveconf(t) = mean(1 ./ (1+exp(-y.*data_confidences)));
+        if t>10 && (aveconf(t)-aveconf(t-10) < stopval)
+            disp(num2str(aveconf))
+            disp(['Stopping after ' num2str(t) ' trees'])            
+            break;
+        end
+        
+    end
+
+    finalconf = 1 ./ (1+exp(-y.*data_confidences));
+    finalerr = (y.*data_confidences < 0);
+    disp(['confidence:: mean: ' num2str(mean(finalconf)) ...
+        '  pos: ' num2str(mean(finalconf(y==1))) ...
+        '  neg: ' num2str(mean(finalconf(y~=1)))]);
+    disp(['training error:: mean: ' num2str(mean(finalerr)) ...
+        '  pos: ' num2str(mean(finalerr(y==1))) ...
+        '  neg: ' num2str(mean(finalerr(y~=1)))]);    
+    all_conf(:, c) = data_confidences+classifier.h0(c);
+  
+end
+
+% compute and display training error
+[tmp, assigned_label] = max(all_conf, [], 2);
+conf_matrix = zeros(num_classes, num_classes);
+for c = 1:num_classes    
+    indices = find(gid==c);
+    for c2 = 1:num_classes
+        conf_matrix(c, c2) = mean(assigned_label(indices)==c2);
+    end
+    disp([gn{c} ' error: ' num2str(mean(assigned_label(indices)~=c))]);
+end
+disp('Confusion Matrix: ');
+disp(num2str(conf_matrix));
+disp(['total error: ' num2str(mean(assigned_label~=gid))]);
+
+
+        

SUN_source_code_v1/code/GeometricContext_dhoiem/src/boosting/tree_getNewVersion.m

@@ -0,0 +1,8 @@
+function dt = tree_getNewVersion(dt)
+
+cut_old = dt.cut;
+dt.cut = num2cell(dt.cut);
+ind = find(dt.var<0);
+for k = 1:numel(ind)
+    dt.cut{ind(k)} = dt.catsplit(cut_old(ind(k)), :);
+end

SUN_source_code_v1/code/GeometricContext_dhoiem/src/boosting/tree_getParameters.m

@@ -0,0 +1,26 @@
+function [var, cut, children, catsplit] = tree_getParameters(dt)
+
+if iscell(dt.cut)
+    var = dt.var;    
+    children = dt.children;
+    
+    cut = zeros(size(dt.cut));
+    catind = var<0;
+    ncat = sum(catind);  
+    catsplit = cell(ncat, 2);
+    ncat = 0;
+    for k = 1:numel(cut)
+        if var(k)>=0
+            cut(k) = dt.cut{k};
+        else
+            ncat = ncat+1;
+            cut(k) = ncat;
+            catsplit(ncat, :) = dt.cut{k};
+        end
+    end      
+else
+    var = dt.var;
+    cut = dt.cut;
+    children = dt.children;
+    catsplit = dt.catsplit;
+end

SUN_source_code_v1/code/GeometricContext_dhoiem/src/boosting/treevalc.c

@@ -0,0 +1,133 @@
+#include "mex.h"
+#include <stdlib.h>
+#include <stdio.h>
+/** 
+ * Return the decision tree node corresponding to the given value set
+ *
+ * var[n]: the attribute ids for node n
+ * cut[n]: the threshold value for node n
+ * left_child[n]: the node id of the left child of node n, 0 if node n is terminal
+ * right_child[n]: the node id of the right child of node n, 0 if node n is terminal
+ * ncatsplit[c]: the number of values resulting in a left branch
+ * catsplit[c]: the values that would result in a left branch
+ * attributes: the attribute (variable) values for each feature
+ **/
+void
+treevalc(int* var, double* cut, int* left_child, int* right_child, 
+	 int* ncatsplit, double** catsplit, 
+	 double* attributes,
+	 int* node_id) {
+ 
+  int currnode = 0;
+
+  int nextnode;
+  int currvar;
+  double currval;
+  int cid, v;
+  int numvals;
+  double* vals;
+
+  /*  printf("init nodes: %d  %d  \n", left_child[currnode], right_child[currnode]); */
+
+  /* until reached terminal node */
+  while ((left_child[currnode] != 0) && (right_child[currnode] != 0)) {
+    
+    /*printf("currnode: %d\n", currnode);*/
+
+    nextnode = -1;
+    
+    currvar = abs(var[currnode])-1;
+    currval = attributes[currvar];
+    
+    /* decision based on thresholded float value */
+    if (var[currnode] > 0) {
+  
+      /*printf("currvar: %d\n", currvar);*/
+
+      /* branch left */
+      if (currval < cut[currnode]) {
+	nextnode = left_child[currnode];
+      }
+      /* branch right */
+      else {
+	nextnode = right_child[currnode];
+      }      
+    }
+    /* decision based on discrete value */
+    else {
+      numvals = ncatsplit[(int)cut[currnode]-1];
+      vals = catsplit[(int)cut[currnode]-1];
+      for (v = 0; v < numvals; v++) {
+	if (currval == vals[v]) {
+	  nextnode = left_child[currnode];
+	  break;
+	}
+      }
+      if (nextnode == -1) {
+	nextnode = right_child[currnode];
+      }
+    }
+    
+    currnode = nextnode-1;
+    /* printf("curr node: %d \n", currnode);*/
+  }
+	  	  
+  *node_id = currnode+1;
+
+}
+
+/**
+ * plhs = {var, cut, left_child, right_child, catsplit(cell array), attributes(numatt, numdata)}
+ *
+ */	 
+void mexFunction(int nlhs, mxArray *plhs[],
+		 int nrhs, const mxArray *prhs[])
+{
+
+  if (nrhs != 6) {
+    printf("Error: wrong number of input arguments: %d.\n", nlhs);
+    printf("Syntax: node_ids = treevalc(var, cut, left_child, right_child, catsplit, attributes)\n");
+  }
+  
+  int* var = (int*)mxGetPr(prhs[0]);
+  double* cut = mxGetPr(prhs[1]);
+  int* left_child = (int*)mxGetPr(prhs[2]);
+  int* right_child = (int*)mxGetPr(prhs[3]);
+  /* get catsplit variables */
+  int nsplits = mxGetNumberOfElements(prhs[4]);
+  int* ncatsplit = malloc(sizeof(int) * nsplits);
+  double** catsplit = malloc(sizeof(double*) * nsplits);
+
+  int n = 0;
+  for (n = 0; n < nsplits; n++) {
+    mxArray* catsplit_cell_mx = mxGetCell(prhs[4], n);
+    if (catsplit_cell_mx == 0) {
+      printf("null cell");
+    }
+    ncatsplit[n] = mxGetNumberOfElements(catsplit_cell_mx);
+    catsplit[n] = (double*)mxGetPr(catsplit_cell_mx);
+  }
+
+  int numatt = mxGetM(prhs[5]);
+  int numdata = mxGetN(prhs[5]);
+
+  /*  printf("num data = %d   num att = %d\n", numdata, numatt);*/
+
+  double* all_attributes = mxGetPr(prhs[5]);
+
+  plhs[0] = mxCreateDoubleMatrix(numdata, 1, mxREAL);
+  double* node_ids = mxGetPr(plhs[0]);
+  
+
+  int tmp_id;
+  for (n = 0; n < numdata; n++) {
+    treevalc(var, cut, left_child, right_child, ncatsplit, catsplit,
+	     &all_attributes[numatt*n], &tmp_id);
+    node_ids[n] = (double)(tmp_id);
+    /*    printf("final node id: %d\n", tmp_id); */
+  }
+
+  free(catsplit);
+  free(ncatsplit);
+  
+}

SUN_source_code_v1/code/GeometricContext_dhoiem/src/geom/APPclassifierOutput2confidenceImages.m

@@ -0,0 +1,56 @@
+function [cimages, cnames] = APPclassifierOutput2confidenceImages(imsegs, conf_maps)
+% Computes confidence maps from results of APPtestImage
+%
+% Copyright(C) Derek Hoiem, Carnegie Mellon University, 2005
+% Current Version: 1.0  09/30/2005
+
+nvclasses = length(conf_maps(1).vnames);
+nhclasses = length(conf_maps(1).hnames);
+nclasses = nvclasses+nhclasses;
+for v = 1:nvclasses
+    cnames{v} = ['v' conf_maps(1).vnames{v}];
+end
+for h = 1:nhclasses
+    cnames{nvclasses+h} = ['h' conf_maps(1).hnames{h}];
+end
+
+
+cimages = cell(length(imsegs), 1);
+
+for f = 1:length(imsegs)
+ 
+    for n = 1:nclasses
+        cim{n} = single(ones(imsegs(f).imsize)/nclasses);
+    end
+        
+%     for s = 1:imsegs(f).nseg
+%         
+%         ind = find(imsegs(f).segimage==s);
+%         
+%         for v = 1:nvclasses
+%             cim{v}(ind) = single(conf_maps(f).vmap(s, v));            
+%         end
+%         for h = 1:nhclasses
+%             cim{nvclasses+h}(ind) = single(conf_maps(f).hmap(s, h));
+%         end
+%         
+%     end
+    
+    cimages{f} = single(zeros([imsegs(f).imsize nclasses]));
+    
+    vind = find(strcmp(cnames, 'v090'));      
+    
+    for n = 1:nclasses
+        if n <= nvclasses
+            %cimages{f}(:, :, n) = cim{n};
+            tmpmap = conf_maps(f).vmap(:, n);
+            cimages{f}(:, :, n) = tmpmap(imsegs(f).segimage);
+        else
+            % multiply P(vclass|X) by P(vertical|X)            
+            tmpmap = conf_maps(f).hmap(:, n-nvclasses);
+            %cimages{f}(:, :, n) = cim{n}.*cim{vind}; 
+            cimages{f}(:, :, n) = tmpmap(imsegs(f).segimage).*cimages{f}(:, :, vind);
+        end
+    end    
+end
+    

SUN_source_code_v1/code/GeometricContext_dhoiem/src/geom/APPestimateHorizon.m

@@ -0,0 +1,79 @@
+function y_h = APPestimateHorizon(lines)
+% Estimates horizon position of image
+% lines should be normalized according to size of image
+% need to multiply output by mean(imsize(1:2)) to get pixel value
+%
+% Copyright(C) Derek Hoiem, Carnegie Mellon University, 2005
+% Current Version: 1.0  09/30/2005
+
+max_angle = pi/8;
+
+% lines(num_lines, [x1 x2 y1 y2 angle r])
+% points(num_points, [y x])
+
+
+a = lines(:, 5);
+x1 = lines(:, 1);
+y1 = lines(:, 3);
+x2 = lines(:, 2);
+y2 = lines(:, 4);
+r = lines(:, 6);
+cosa = cos(a);
+sina= sin(a);
+tana = tan(a);
+
+max_dist = 1E2;
+
+num_lines = size(lines, 1);
+if num_lines <= 1
+    points = zeros(0, 2);
+    return;
+end
+
+num_pairs = num_lines*(num_lines-1)/2;
+
+adist = pdist(a, 'cityblock');
+%adist = mod(adist, pi/2) < max_angle;
+adist = adist < max_angle;
+adistM = squareform(adist);
+
+points = zeros(num_pairs, 2);
+count = 0;
+for i = 1:num_lines
+    for j = i+1:num_lines
+        if adistM(i, j) & (r(i)~=r(j) | a(i)~=a(j))
+            count = count+1;            
+            if a(i) == a(j) | a(i) == -a(j) % parallel but not colinear
+                points(count, 1:2) = ([x1(i) y1(i)]+[x1(j) y1(j)])/2 + [sina(i) cosa(i)]*max_dist;
+            else
+                m1 = tana(i);
+                m2 = tana(j);
+                points(count, 1) = (-y1(i)*m2+m1*y1(j)-m1*m2*x1(j)+m1*x1(i)*m2)/(m1-m2);
+                points(count, 2) = (y1(j)-y1(i)+m1*x1(i)-m2*x1(j))/(m1-m2);                
+                if abs(points(count, 1))==Inf | abs(points(count, 2))==Inf
+                    points(count, 1:2) = ([x1(i) y1(i)]+[x1(j) y1(j)])/2 + [sina(i) cosa(i)]*max_dist;
+                end
+                    
+            end
+        end
+    end
+end
+
+points = points(1:count, :);
+
+%ind = find(abs(points(:, 2))<0.02);% & abs(points(:, 1)) < 0.75);
+%tpoints = points(ind, :);
+
+if size(points, 1) == 0
+    y_h = 0.5;
+else
+    y_h = 0.5+fminbnd(@sum_distance, -2, 2, [], points(:, 1));
+end
+
+
+
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+function d = sum_distance(x, pts)
+d = sum(sqrt(abs(x-pts)));

SUN_source_code_v1/code/GeometricContext_dhoiem/src/geom/APPestimateVp.m

@@ -0,0 +1,228 @@
+function [v2, sigma, p, hpos] = APPestimateVp(lines, imsize, DO_DISPLAY)
+% [v2, sigma, p, hpos] = APPestimateVp(lines, imsize, DO_DISPLAY)
+% Estimates the principal vanishing points, as in Video Compass [Kosecka
+% 2002], except that more (or fewer) than 3 principal vps could be found
+% 
+% Input:
+% lines([x1 x2 y1 y2 angle r])
+% imsize: size of image
+% DO_DISPLAY (optional): whether to create display figures (default=0)
+% Output:
+% v2(nvp, [x y]) - the found vanishing points; last is outliers; vp are in
+%                  units of pixels/imsize(1), with image upper-left at (0,0)                  
+% sigma(nvp) - the variance for each vp
+% p(nlines, nvp) - the confidence that each line belongs to each vp
+% hpos - horizon position (0 is top of image)
+%
+% Copyright(C) Derek Hoiem, Carnegie Mellon University, 2005
+% Current Version: 1.0  09/30/2005
+
+if ~exist('DO_DISPLAY')
+    DO_DISPLAY = 0;
+end
+
+nlines = size(lines, 1);
+
+x1 = [lines(:, [1 3]) ones(size(lines, 1), 1)];
+x2 = [lines(:, [2 4]) ones(size(lines, 1), 1)];
+
+% get plane normals for line segments
+l = cross(x1, x2);
+l = l ./ repmat(sqrt(sum(l.^2,2)), 1, 3);
+
+% make theta range from 0 to pi (instead of -pi to pi)
+nbins = 60;
+theta = mod(lines(:,5), pi);
+
+% get histogram of thetas
+binwidth = pi/nbins;
+bincenters = [(binwidth/2):binwidth:(pi-binwidth/2)];
+hist_theta = hist(theta, bincenters);
+
+% smooth histogram
+for b = 1:nbins
+    hist_theta(b) = sum(hist_theta(mod([(b-1):(b+1)]-1, nbins)+1) .* [0.25 0.5 0.25]);
+end
+
+% compute curvature of histogram
+s = 9;
+C = zeros(1, nbins);
+for b = 1:nbins
+    C(b) = hist_theta(b) - mean(hist_theta(mod([(b-(s-1)/2):(b+(s-1)/2)]-1, nbins)+1));
+end
+
+
+% find dominant peaks surrounded by zero crossings
+zc_pos = find((C > 0) & ([C(end) C(1:end-1)]<0));
+zc_neg = find((C < 0) & ([C(end) C(1:end-1)]>0));
+
+ngroups = length(zc_pos);
+bc = bincenters + pi/nbins/2;
+if zc_neg(1) < zc_pos(1)
+    i1 = round((zc_pos(end)+zc_neg(end))/2);
+    i2 = round((zc_neg(1) + zc_pos(1))/2);
+    groups{1} = find((theta > bc(i1)) | (theta < bc(i2)));
+    for i = 2:ngroups
+        i1 = round((zc_pos(i-1)+zc_neg(i-1))/2);
+        i2 = round((zc_neg(i) + zc_pos(i))/2);     
+        groups{i} = find((theta > bc(i1)) & (theta < bc(i2)));
+    end
+
+else
+    for i = 1:ngroups
+        i1 = ceil((zc_pos(i)+zc_neg(max(i-1,1)))/2);
+        i2 = ceil((zc_neg(i) + zc_pos(min(i+1,ngroups)))/2);
+        groups{i} = find((theta > bc(i1)) & (theta < bc(i2)));       
+    end
+end
+
+% remove groups with few segments 
+remove = [];
+thresh = max(0.05*nlines, 5);
+%thresh = 6;
+for i = 1:ngroups
+    if length(groups{i}) < thresh
+        %disp(num2str([length(groups{i}) nlines]))
+        remove(end+1) = i;
+    end
+end
+groups(remove) = [];
+ngroups = length(groups);
+
+
+% initialize EM
+sigma = ones(1, ngroups); % sigma = variance here
+p = zeros(nlines, ngroups); % p = P(v | l) = P(l|v)P(v)/P(l)
+for i = 1:ngroups
+    p(groups{i}, i) = 1;
+end
+%p(:, end) = 1-sum(p(:, 1:end-1), 2);
+A = l;
+v = [];
+sigma = [];
+for i = 1:ngroups
+    normp = p(:, i) / sum(p(:, i));
+    W = diag(normp);
+    [eigV, lambda] = eig(A'*W'*W*A);
+    [tmp, smallest] = min(diag(lambda));
+    v(1:3,i) = eigV(:, smallest);
+    sp = sort(normp, 'descend');
+    sp = sum(sp(1:min(length(sp), 2)));
+    sigma(i) = normp' * (l*v(:,i)).^2 / (1-sum(sp));
+end
+
+% create outlier groups
+nadd = 3;
+ngroups = ngroups + nadd;
+sigma(end+(1:nadd)) = 0.2;
+tmpv = [0 0 1]';
+v(1:3, end+1) = tmpv / sqrt(sum(tmpv.^2));
+tmpv = [1 0 1]';
+v(1:3, end+1) = tmpv / sqrt(sum(tmpv.^2));
+tmpv = [-1 0 1]';
+v(1:3, end+1) = tmpv / sqrt(sum(tmpv.^2));
+p(:, end+(1:nadd)) = 0;
+pv = ones(1, ngroups);
+
+oldv = v;
+
+% do EM
+for iter = 1:15
+    oldp = p;
+    pv = pv / sum(pv);
+    % p(l|v) = 1/sqrt(2*pi)/sigma*exp(-(l'v).^2/sigma^2/2) 
+    S = repmat(sigma, nlines, 1) + 1E-10;
+    plv = exp(-(l*v).^2 ./ S / 2) ./ sqrt(S) + 1E-10;        
+    p = plv .* repmat(pv, nlines, 1);    
+    p = p ./ repmat(sum(p, 2), 1, ngroups);  
+    pv = sum(p, 1);
+    nmembers = zeros(ngroups,1);
+    for i = 1:ngroups
+        normp = p(:, i) / sum(p(:, i));
+        W = diag(normp);
+        [eigV, lambda] = eig(A'*W'*W*A);
+        [tmp, smallest] = min(diag(lambda));
+        v(1:3,i) = eigV(:, smallest);            
+        sp = sort(normp, 'descend');
+        sp = sum(sp(1:min(length(sp), 2)));
+        if (1-sum(sp)) > 0
+            sigma(i) = normp' * (l*v(:,i)).^2 / (1-sum(sp)); 
+        else
+            sigma(i) = Inf;                       
+        end
+    end        
+
+    % remove duplicate groups
+    remove =[];
+    for i = 1:ngroups        
+        for j = i+1:ngroups
+            if (v(1:3, i)'*v(1:3,j) > 0.995) || (pv(i)*nlines <= 3) || (sigma(i) > 10) 
+                remove(end+1) = i;
+                break;
+            end
+        end
+    end
+    if length(remove)>0
+        p(:, remove) = [];
+        sigma(remove) = [];
+        v(:, remove) = [];
+        pv(remove) = [];
+        ngroups = size(p, 2);
+    end
+    
+    % break when v converges
+    if all(size(v)==size(oldv)) && min(diag(oldv'*v)) > 0.999
+        break;
+    end    
+    oldv = v;
+    
+end
+
+% convert vanishing directions to [x y 1] form with (0,0) in upper-left of
+% image
+%A = inv([1/imsize(1) 0 -1/imsize(2)/2*imsize(1); 0 1/imsize(1) -1/imsize(1)/2*imsize(1); 0 0 1]);
+%v2 = (A*v)';
+v2 = v';
+v2(:, 3) = v2(:, 3)+1E-4;
+% sigma = sigma ./ (v2(:, 3).^2)';
+v2 = v2 ./ repmat(v2(:, 3), 1, 3);
+v2(:, 1) = v2(:, 1) + imsize(2)/imsize(1)/2;
+v2(:, 2) = v2(:, 2) + 1/2;
+
+if nargout > 3
+    hpos = APPvp2horizon(v2, sigma, p, imsize);
+end
+%v2 = v;
+
+if DO_DISPLAY
+
+    figure(1), hold off, plot(bincenters, hist_theta, 'b');    
+    figure(1), hold on, plot(bincenters, hist_theta, 'r');
+    drawnow;
+
+    edge_im = zeros(imsize);
+    lines_nnorm(:, [1 2]) = lines(:, [1 2])*imsize(1) + imsize(2)/2;
+    lines_nnorm(:, [3 4]) = lines(:, [3 4])*imsize(1) + imsize(1)/2;
+    %lines_nnorm = lines;
+    for i = 1:length(groups)
+        if length(groups{i})>0
+            edge_im = draw_line_image2(edge_im, lines_nnorm(groups{i}, 1:4)', i);
+        end
+    end
+    figure(2), imshow(255-label2rgb(edge_im));  
+    
+    % plot new line memberships
+    [tmp, bestv] = max(p, [], 2);    
+    edge_im = zeros(imsize);
+    for i = 1:ngroups
+        groups{i} = find(bestv==i);
+        if length(groups{i})>0
+            edge_im = draw_line_image2(edge_im, lines_nnorm(groups{i}, 1:4)', i);
+        end
+        %disp(length(groups{i}))
+    end
+    figure(3), imshow(255-label2rgb(edge_im));    
+    drawnow; 
+end
+
+

SUN_source_code_v1/code/GeometricContext_dhoiem/src/geom/APPgetImageFilters.m

@@ -0,0 +1,29 @@
+function [doog_filters, texton_data] = APPgetImageFilters;
+% Gets filters for creating texture features
+
+% create pair data
+angle_step = 15;
+filter_size = 5;
+sigma = 1.5;
+r = 0.25;
+
+% create difference of oriented gaussian filters
+num_angles=180/angle_step;
+doog_filters = zeros(filter_size, filter_size, num_angles);
+for (theta=0:angle_step:180-angle_step)
+    doog_filters(:, :, theta/angle_step+1)=createDoogFilter(sigma, r, theta, filter_size); 
+end
+
+% load textons
+if 0 % DWH no longer uses textons
+texton_data = load('unitex_6_1_2_1.4_2_32.mat'); % from Berkeley database
+ordered_textons = select_diverse_textons(texton_data.tsim, 12);
+new_tims = cell(length(ordered_textons), 1);
+for i = 1:length(new_tims)
+    new_tims{i} = texton_data.tim{ordered_textons(i)};
+end
+texton_data.tim = new_tims;
+end
+
+texton_data.tim = [];
+%num_textons = length(texton_data.tim);

SUN_source_code_v1/code/GeometricContext_dhoiem/src/geom/APPgetLabeledImage.m

@@ -0,0 +1,120 @@
+function image = APPgetLabeledImage(image, imsegs, vLabels, vConf, hLabels, hConf)
+% image = APPgetLabeledImage(image, imsegs, vLabels, vConf, hLabels, hConf)
+%
+% Copyright(C) Derek Hoiem, Carnegie Mellon University, 2005
+% Current Version: 1.0  09/30/2005
+%image = image / double(max(image(:)));
+
+scale = size(image, 1) / size(vLabels, 1);
+
+image = rgb2hsv(image);
+image(:, :, 2) = 0.0*image(:, :, 2);
+image = hsv2rgb(image);
+           
+drawn = zeros(size(vLabels));
+
+rad = round(max(size(image))/30);
+markW = ceil(rad/10);
+right_arrow = struct('x', 0, 'y', 0, 'angle', 0, 'radius', rad, 'head_length', rad/2, 'head_base_angle', 30);
+up_arrow = struct('x', 0, 'y', 0, 'angle', 90, 'radius', rad, 'head_length', rad/2, 'head_base_angle', 30);
+up_left_arrow = struct('x', 0, 'y', 0, 'angle', 135, 'radius', rad, 'head_length', rad/2, 'head_base_angle', 30);    
+up_right_arrow = struct('x', 0, 'y', 0, 'angle', 45, 'radius', rad, 'head_length', rad/2, 'head_base_angle', 30);    
+left_arrow = struct('x', 0, 'y', 0, 'angle', 180, 'radius', rad, 'head_length', rad/2, 'head_base_angle', 30);
+down_arrow = struct('x', 0, 'y', 0, 'angle', 270, 'radius', rad, 'head_length', rad/2, 'head_base_angle', 30);     
+toward_arrow = struct('x', 0, 'y', 0, 'angle', 250, 'radius', rad*2/3, 'head_length', rad/3, 'head_base_angle', 60);
+
+nsegs = imsegs.nseg;
+sinds = APPgetSpIndsOld((1:nsegs), imsegs);
+for s = 1:nsegs
+
+    ind = sinds(s).inds;
+    
+    sat = max(min(vConf(s), 1), 0.33);
+
+    val = 1;
+    mix_rat = 0.5;
+    arrows = [];
+    hue = 0;
+    if strcmp(vLabels{s}, 'sky')
+        hue = 177/255;
+    elseif strcmp(vLabels{s}, '000')
+        hue = 112/255;
+        % elseif strcmp(vLabels{s}, 'rnd') | strcmp(hLabels{s}, 'rnd')
+       % hue = 226/255;        
+    elseif strcmp(vLabels{s}, '045')
+        %hue = 45/255;
+        hue = 0/255;
+    elseif strcmp(vLabels{s}, '090')
+        hue = 0/255;
+        %hue = 0/255;
+    elseif strcmp(vLabels{s}, 'dst')
+        %hue = 80/255;
+        %sat = sat/2;
+        hue = 0/255;
+    else
+        disp(vLabels{s})
+        sat = 0;
+    end
+    %if strcmp(hLabels{s}, 'rnd') & (strcmp(vLabels{s}, '090') | strcmp(vLabels{s}, '045'))
+    %    hue = 0/255;
+    %    sat = sat/2;
+    %end
+   
+    
+        
+    width = size(image, 2);
+    height = size(image, 1);
+
+    % fill in region with color determined by label
+    colors = hsv2rgb([hue sat val]);
+    label_colors = colors;
+    
+    colors = reshape(colors, [1 1 3]);
+
+    y_ind = mod(ind-1, height)+1;
+    x_ind = floor((ind-1)/height)+1;
+    for s = 1:length(ind)
+        image(y_ind(s), x_ind(s), (1:3)) = (1-mix_rat)*image(y_ind(s), x_ind(s), :) + mix_rat*colors;
+    end
+
+end
+if 1
+    
+for x = rad:round(rad*1.51):(width-rad)
+    for y = rad:round(rad*1.51):(height-rad)
+        
+        hlabel = hLabels{imsegs.segimage(y, x)};
+        vlabel = vLabels{imsegs.segimage(y, x)};
+        
+        intensity = 0;
+        label_colors = [1 1 1];
+        
+        arrows = [];
+        if strcmp(vlabel, '090') | strcmp(vlabel, '045')
+            if strcmp(hlabel, '045')
+                arrows = left_arrow;
+            elseif strcmp(hlabel, '090')
+                arrows = up_arrow;
+            elseif strcmp(hlabel, '135')
+                arrows = right_arrow;                
+            elseif strcmp(hlabel, 'por')
+                image = draw_circle_image(image, x, y, rad/2, 0, markW);
+            elseif strcmp(hlabel, 'sol')
+                image = draw_x_image(image, x, y, rad, 0, markW);
+            end
+                
+        end
+        
+        % draw arrows                     
+        for a = 1:length(arrows)
+            arrows(a).x = x;
+            arrows(a).y = y; 
+        end
+
+        image = draw_arrow_image(image, arrows, 0, markW);              
+        
+    end
+     
+end
+end
+

SUN_source_code_v1/code/GeometricContext_dhoiem/src/geom/APPgetLabeledImage2.m

@@ -0,0 +1,106 @@
+function image = APPgetLabeledImage2(image, imsegs, pv, ph)
+% image = APPgetLabeledImage2(image, imsegs, pv, ph)
+%
+% Copyright(C) Derek Hoiem, Carnegie Mellon University, 2006
+% Current Version: 2.0  04/22/2006
+%image = image / double(max(image(:)));
+
+%grayim = rgb2gray(image);
+image = rgb2hsv(image);
+image(:, :, 2) = 0.0*image(:, :, 2);
+image = hsv2rgb(image);
+           
+rad = round(max(size(image))/20);
+markW = ceil(rad/10);
+right_arrow = struct('x', 0, 'y', 0, 'angle', 0, 'radius', rad, 'head_length', rad/2, 'head_base_angle', 30);
+up_arrow = struct('x', 0, 'y', 0, 'angle', 90, 'radius', rad, 'head_length', rad/2, 'head_base_angle', 30);
+up_left_arrow = struct('x', 0, 'y', 0, 'angle', 135, 'radius', rad, 'head_length', rad/2, 'head_base_angle', 30);    
+up_right_arrow = struct('x', 0, 'y', 0, 'angle', 45, 'radius', rad, 'head_length', rad/2, 'head_base_angle', 30);    
+left_arrow = struct('x', 0, 'y', 0, 'angle', 180, 'radius', rad, 'head_length', rad/2, 'head_base_angle', 30);
+down_arrow = struct('x', 0, 'y', 0, 'angle', 270, 'radius', rad, 'head_length', rad/2, 'head_base_angle', 30);     
+toward_arrow = struct('x', 0, 'y', 0, 'angle', 250, 'radius', rad*2/3, 'head_length', rad/3, 'head_base_angle', 60);
+
+vhue = [112 0 177]/255;
+
+if ~isstruct(imsegs)
+    tmp = imsegs;
+    clear imsegs;
+    imsegs.segimage = tmp;
+end
+
+if ndims(pv)==2
+    [vconf, vlab] = max(pv, [], 2);
+    [hconf, hlab] = max(ph, [], 2);
+
+    vlabim = vlab(imsegs.segimage);
+    hlabim = hlab(imsegs.segimage);
+    hconfim = hconf(imsegs.segimage);
+    %vconf = max((vconf - 0.5)*2, 0);
+    %vconf = max(vconf, 1);
+
+    hueim = vhue(vlabim);
+    satim = vconf(imsegs.segimage);
+    valim = ones(size(hueim));
+else
+    [satim, vlabim] = max(pv, [], 3);
+    [hconfim, hlabim] = max(ph, [], 3);
+    hueim = vhue(vlabim);
+    valim = ones(size(hueim));    
+end
+
+% set color 
+image = image*0.5 + 0.5*hsv2rgb(hueim, satim, valim);  
+
+% draw boundaries of main classes
+% [gx, gy] = gradient(vlabim);
+% g = gx.^2 + gy.^2;
+% g = conv2(g, ones(2), 'same');
+% edgepix = find(g>0);
+% npix = numel(hueim);
+% for b = 1:3
+%     image((b-1)*npix+edgepix) = 0;
+% end
+
+
+
+if 1 % set do draw subclass marks
+    
+%hconfim = max((hconf(imsegs.segimage)-0.5)*2, 0);    
+
+height = size(image, 1);  width = size(image, 2);
+
+for x = rad:round(rad*1.51):(width-rad)
+    for y = rad:round(rad*1.51):(height-rad)
+               
+        %val = 1-hconfim(y, x);
+        val = [0 0 0];
+        
+        arrows = [];
+        if vlabim(y, x)==2 % vertical
+            if hlabim(y, x)==1 % left
+                arrows = left_arrow;
+            elseif hlabim(y, x)==2 % center
+                arrows = up_arrow;
+            elseif hlabim(y, x)==3 % right
+                arrows = right_arrow;                
+            elseif hlabim(y, x)==4 % porous
+                image = draw_circle_image(image, x, y, rad/2, val, markW);
+            elseif hlabim(y, x)==5 % solid
+                image = draw_x_image(image, x, y, rad, val, markW);
+            end
+                
+        end
+        
+        % draw arrows                     
+        for a = 1:length(arrows)
+            arrows(a).x = x;
+            arrows(a).y = y; 
+        end
+
+        image = draw_arrow_image(image, arrows, val, markW);              
+        
+    end
+     
+end
+end
+

SUN_source_code_v1/code/GeometricContext_dhoiem/src/geom/APPgetLabeledImage2.m~

@@ -0,0 +1,96 @@
+function image = APPgetLabeledImage2(image, imsegs, pv, ph)
+% image = APPgetLabeledImage2(image, imsegs, vLabels, vConf, hLabels, hConf)
+%
+% Copyright(C) Derek Hoiem, Carnegie Mellon University, 2005
+% Permission granted to non-commercial enterprises for
+% modification/redistribution under GNU GPL.  
+% Current Version: 2.0  04/22/2006
+%image = image / double(max(image(:)));
+
+%grayim = rgb2gray(image);
+image = rgb2hsv(image);
+image(:, :, 2) = 0.0*image(:, :, 2);
+image = hsv2rgb(image);
+           
+rad = round(max(size(image))/25);
+markW = ceil(rad/10);
+right_arrow = struct('x', 0, 'y', 0, 'angle', 0, 'radius', rad, 'head_length', rad/2, 'head_base_angle', 30);
+up_arrow = struct('x', 0, 'y', 0, 'angle', 90, 'radius', rad, 'head_length', rad/2, 'head_base_angle', 30);
+up_left_arrow = struct('x', 0, 'y', 0, 'angle', 135, 'radius', rad, 'head_length', rad/2, 'head_base_angle', 30);    
+up_right_arrow = struct('x', 0, 'y', 0, 'angle', 45, 'radius', rad, 'head_length', rad/2, 'head_base_angle', 30);    
+left_arrow = struct('x', rad/2, 'y', 0, 'angle', 180, 'radius', rad, 'head_length', rad/2, 'head_base_angle', 30);
+down_arrow = struct('x', 0, 'y', -rad/2, 'angle', 270, 'radius', rad, 'head_length', rad/2, 'head_base_angle', 30);     
+toward_arrow = struct('x', 0, 'y', 0, 'angle', 250, 'radius', rad*2/3, 'head_length', rad/3, 'head_base_angle', 60);
+
+vhue = [112 0 177]/255;
+
+[vconf, vlab] = max(pv, [], 2);
+[hconf, hlab] = max(ph, [], 2);
+
+vlabim = vlab(imsegs.segimage);
+hlabim = hlab(imsegs.segimage);
+
+%vconf = max((vconf - 0.5)*2, 0);
+%vconf = max(vconf, 1);
+
+hueim = vhue(vlabim);
+satim = vconf(imsegs.segimage);
+valim = ones(size(hueim));
+
+% set color 
+image = image*0.5 + 0.5*hsv2rgb(hueim, satim, valim);  
+
+% draw boundaries of main classes
+% [gx, gy] = gradient(vlabim);
+% g = gx.^2 + gy.^2;
+% g = conv2(g, ones(2), 'same');
+% edgepix = find(g>0);
+% npix = numel(hueim);
+% for b = 1:3
+%     image((b-1)*npix+edgepix) = 0;
+% end
+
+
+
+if 1 % set do draw subclass marks
+    
+%hconfim = max((hconf(imsegs.segimage)-0.5)*2, 0);    
+hconfim = hconf(imsegs.segimage);
+
+[height, width] = size(imsegs.segimage);
+
+for x = rad:round(rad*1.51):(width-rad)
+    for y = rad:round(rad*1.51):(height-rad)
+               
+        %val = 1-hconfim(y, x);
+        val = 0;
+        
+        arrows = [];
+        if vlabim(y, x)==2 % vertical
+            if hlabim(y, x)==1 % left
+                arrows = left_arrow;
+            elseif hlabim(y, x)==2 % center
+                arrows = up_arrow;
+            elseif hlabim(y, x)==3 % right
+                arrows = right_arrow;                
+            elseif hlabim(y, x)==4 % porous
+                image = draw_circle_image(image, x, y, rad/2, val, markW);
+            elseif hlabim(y, x)==5 % solid
+                image = draw_x_image(image, x, y, rad, val, markW);
+            end
+                
+        end
+        
+        % draw arrows                     
+        for a = 1:length(arrows)
+            arrows(a).x = x;
+            arrows(a).y = y; 
+        end
+
+        image = draw_arrow_image(image, arrows, val, markW);              
+        
+    end
+     
+end
+end
+

SUN_source_code_v1/code/GeometricContext_dhoiem/src/geom/APPgetLargeConnectedEdges.m

@@ -0,0 +1,173 @@
+function [lines, spdata, edgeIm] = APPgetLargeConnectedEdges(grayIm, minLen, imsegs)
+% [lines, spdata, edgeIm] = APPgetLargeConnectedEdges(grayIm, minLen,
+%                                 imsegs)
+% 
+% Uses the method of Video Compass [Kosecka, et al 2002] to get long,
+% straight edges.
+% 
+% Input:
+%   grayIm: grayscale image to be analyzed
+%   minLen: minimum length in pixels for edge (suggested 0.025*diagonal)
+%   imsegs: superpixel image structure (used to store sp statistics)
+% Output:
+%   lines: parameters for long, straight lines
+%   spdata: statistics for lines in each superpixel
+%   edgeIm (optional): for displaying lines found
+%
+% Copyright(C) Derek Hoiem, Carnegie Mellon University, 2005
+% Current Version: 1.0  09/30/2005
+
+
+[dX, dY] = gradient(conv2(grayIm, fspecial('gaussian', 7, 1.5), 'same'));
+
+im_canny = edge(grayIm, 'canny');
+% remove border edges
+im_canny([1 2 end-1 end], :) = 0;
+im_canny(:, [1 2 end-1 end]) = 0;
+width = size(im_canny, 2);
+height = size(im_canny, 1);
+
+ind = find(im_canny > 0);
+
+num_dir = 8;
+
+dX_ind = dX(ind);
+dY_ind = dY(ind);
+a_ind = atan(dY_ind ./ (dX_ind+1E-10));
+
+% a_ind ranges from 1 to num_dir with bin centered around pi/2
+a_ind = ceil(mod(a_ind/pi*num_dir-0.5, num_dir));
+%[g, gn] = grp2idx(a_ind);
+
+% get the indices of edges in each direction
+for i = 1:num_dir
+    direction(i).ind = ind(find(a_ind==i));
+end
+
+
+% remove edges that are too small and give all edges that have the same
+% direction a unique id
+% edges(height, width, [angle id])
+if nargout>2
+    edgeIm = grayIm*0.75;
+end
+lines = zeros(2000, 6);
+
+nspdata = length(imsegs.npixels);
+spdata = repmat(struct('lines', zeros(5, 1), 'edge_count', 0), nspdata,1);
+bcount = zeros(nspdata, 1);
+
+used = zeros(size(im_canny));
+
+line_count = 0;
+for k = 1:num_dir
+    
+    num_ind = 0;
+    for m = (k-1):k+1
+        num_ind = num_ind + sum(~used(direction(mod(m-1, num_dir)+1).ind));
+    end
+    
+    ind = zeros(num_ind, 1);
+    dir_im = zeros(size(im_canny));
+  
+    count = 0;
+    for m = (k-1):k+1
+        m2 = mod(m-1, num_dir)+1;
+        tind = direction(m2).ind(find(~used(direction(m2).ind)));
+        tmpcount = length(tind);
+        ind(count+1:count+tmpcount) = tind;
+        count = count + tmpcount;
+    end
+    dir_im(ind) = 1;
+        
+    [tmpL, num_edges] = bwlabel(dir_im, 8); 
+    
+    % get the number of pixels in each edge
+    edge_size = zeros(num_edges, 1);
+    edges = repmat(struct('ind', zeros(200, 1)), num_edges, 1);
+    for i = 1:length(ind)
+        id = tmpL(ind(i));
+        edge_size(id) = edge_size(id) + 1;
+        edges(id).ind(edge_size(id)) = ind(i);
+    end          
+    for i = 1:num_edges
+        edges(i).ind = edges(i).ind(1:edge_size(i));
+    end        
+       
+    % get the endpoints of the long edges and an image of the long edges
+    for id = 1:num_edges
+        if edge_size(id) > minLen         
+                                    
+            y = mod(edges(id).ind-1, height)+1;
+            x = floor((edges(id).ind-1) / height)+1;            
+            
+            %by = min(floor(y/block_size), ny-1);
+            %bx = min(floor(x/block_size), nx-1);
+            
+            mean_x = mean(x);
+            mean_y = mean(y);
+            zmx = (x-mean_x);
+            zmy = (y-mean_y);
+            D = [sum(zmx.^2) sum(zmx.*zmy); sum(zmx.*zmy) sum(zmy.^2)];
+            [v, lambda] = eig(D);
+            theta = atan2(v(2, 2) , v(1, 2));                       
+            if lambda(1,1)>0
+                conf = lambda(2,2)/lambda(1,1);
+            else
+                conf = 100000;
+            end
+                
+            %disp(conf)
+            
+            if conf >= 400 
+                line_count = line_count+1;
+                
+                used(edges(id).ind) = 1;
+                bi = double(imsegs.segimage(edges(id).ind));
+                [g, gn] = grp2idx(bi);
+                for k = 1:length(bi)
+                    if bi(k) > 0
+                        spdata(bi(k)).edge_count = spdata(bi(k)).edge_count + 1;
+                    end
+                end
+                for k = 1:length(gn)
+                    tmpbi = str2num(gn{k});
+                    if tmpbi>0
+                        bcount(tmpbi) = bcount(tmpbi)+1;
+                        spdata(tmpbi).lines(bcount(tmpbi)) = line_count;                
+                    end
+                end                
+                
+                %disp(num2str([lambda(1,1) lambda(2,2)]))
+                r = sqrt((max(x)-min(x))^2 + (max(y)-min(y))^2);
+                x1 = mean_x - cos(theta)*r/2;
+                x2 = mean_x + cos(theta)*r/2;
+                y1 = mean_y - sin(theta)*r/2;
+                y2 = mean_y + sin(theta)*r/2;            
+                
+                r = mean_x*cos(theta)+mean_y*sin(theta);
+                %tr = x1*cos(theta) + y1*sin(theta);
+                %disp(num2str([r tr]))
+                
+                lines(line_count, 1:6) = [x1 x2 y1 y2 theta r];
+	
+            end
+        end
+    end
+
+end
+
+
+if nargout>2
+    for i = 1:line_count
+        edgeIm = draw_line_image2(edgeIm, lines(i, 1:4)', i);
+    end
+end
+
+for k = 1:length(spdata)
+    spdata(k).lines = spdata(k).lines(1:bcount(k))';
+end
+lines = lines(1:line_count, :);
+
+imsize = size(grayIm);
+lines = normalizeLines(lines, imsize(1:2));

SUN_source_code_v1/code/GeometricContext_dhoiem/src/geom/APPgetPairwiseSuperpixelLikelihoods.m

@@ -0,0 +1,20 @@
+function Z = APPgetPairwiseSuperpixelLikelihoods(features, density)
+% Z = APPgetPairwiseSuperpixelLikelihoods(features, density)
+% Gets the matrix of pairwise sp likelihoods
+
+nElements = size(features, 1);
+nFeatures = size(features, 2);
+nDist = nElements*(nElements-1)/2;
+
+% Y contains all pairwise likelihoods of being in same cluster
+Y = zeros(nDist, 1);
+count = 0;
+for f = 1:nFeatures
+    tmpY = pdist(features(:, f), 'cityblock');
+    % minus used because log ratio is of P(x|+)/P(x|-), but we want inverse    
+    %% NOW plus used for similarity
+    Y = Y + getKdeLikelihood(density(f).log_ratio, density(f).x, tmpY);
+end
+
+Z = squareform(Y');
+Z = Z.*(ones(nElements, nElements)-eye(nElements));

SUN_source_code_v1/code/GeometricContext_dhoiem/src/geom/APPgetRegionFeatures.m

@@ -0,0 +1,204 @@
+function regionFeatures = APPgetRegionFeatures(image, imsegs, currMap, ...
+                                regionNums, spdata, vpdata)
+% regionFeatures = APPgetRegionFeatures(image, imsegs, currMap, ...
+%                                regionNums, spdata, vpdata)                            
+% Computes features for segments given by currMap
+%
+% Input:
+%   image: image to be analyzed
+%   imsegs: sp structure
+%   currMap: maps sp to regions
+%   regionNums: indices of regions to be analyzed
+%   spdata: sp data structure from APPgetSpData
+%   vpdata: vanishing point data structure
+% Output:
+%   regionFeatures(nRegions, nFeatures): region features
+% 
+% Assuming there are 12 oriented filters and 12 texton filters the
+% features are as follows:
+% 1-12: mean abs oriented filter responses (ofr)
+% 13: edginess - mean of all ofrs
+% 14: index of largest ofr
+% 15: dominance of largest response - max - median of ofr
+% textons (would be 16-29) not often used 
+%       16-27: mean abs texton filter response (tfr)
+%       28: index of largest tfr
+%       29: dominance of largest tfr (max - med)
+% 16-18: red, green, blue means
+% 19-21: hue, saturation, value means (rgb2hsv)
+% 22-23: y location, x location means
+% 24-29: hue - histogram (5 bins), entropy
+% 30-33: sat - histogram (3 bins), entropy
+% 34-37: location - 10% and 90% (percentiles) y and x 
+% 38-39: edginess center y and x
+% 40: number of super-pixels in segmentation
+% 41: % of image area region takes up
+% 42: number of sides in convex hull polygon
+% 43: (num pixels) / (area of convex hull polygon)
+% 44: whether the region is contiguous
+% 45-60: vanishing point features (see vp2regionfeatures)
+% 61-62: 10% and 90% y wrt horizon
+% 63   : 0-> below horizon, 1-> straddles horizon, 2-> above horizon
+% 64-82: older vanishing point features (see lines_to_vp_info3)
+% discrete: 14 44 60 63
+%
+% Copyright(C) Derek Hoiem, Carnegie Mellon University, 2005
+% Current Version: 1.0  09/30/2005
+
+% WARNING: not using texton features
+
+num_clusters = length(regionNums);
+
+regionFeatures = zeros(num_clusters, 82);
+
+num_angles = size(spdata.orientation,2);
+num_textons = 0;
+
+spfeatures = spdata.features; % superpixel features
+pixelp = imsegs.npixels ./ sum(imsegs.npixels);
+sporient = spdata.orientation;
+
+height = size(image, 1);
+width = size(image, 2);
+
+hue = spdata.hue;
+sat=  spdata.sat;
+yim = 1-repmat([(0:height-1)/(height-1)]', 1, width);
+xim = repmat([(0:width-1)/(width-1)], height, 1);
+
+cinds = APPspInds2regionInds(currMap, imsegs.seginds);
+edgeim = spdata.edginess;
+
+for c = 1:num_clusters
+    
+    spind = find(currMap==regionNums(c));
+    cpixelp = pixelp(spind);
+    %cpixelp = cpixelp / sum(cpixelp); % line added 02/20/06
+    
+    % features consisting of mean block responses    
+    
+    % mean orientation filter responses
+    rorient = zeros(num_angles, 1);
+    for a = 1:num_angles
+        regionFeatures(c, a) = sum(spfeatures(spind, a).*cpixelp);
+        rorient(a) = sum(sporient(spind, a).*cpixelp);        
+    end
+    % mean edginess (overall response)
+    regionFeatures(c, num_angles+1) = sum(spfeatures(spind, num_angles+1).*cpixelp);
+    % most dominant filter response
+    [tmp, regionFeatures(c, num_angles+2)] = max(rorient); 
+    % dominance of largest filter (max - median)    
+    regionFeatures(c, num_angles+3) = max(rorient) - median(rorient);   
+	% mean texton response
+    for t = 1:num_textons
+        regionFeatures(c, num_angles+3+t) = sum(spfeatures(spind, num_angles+t).*cpixelp);
+    end
+    nf = num_angles+3+num_textons;
+    if num_textons>0
+        % most dominant texton response
+        [tmp, regionFeatures(c, nf+1)] = max(regionFeatures(c, num_angles+3+(1:num_textons))); 
+        % dominance of largest texton reponse
+        regionFeatures(c, nf+2) = regionFeatures(c, nf+1) - median(regionFeatures(c, num_angles+3+(1:num_textons)));
+        nf = nf +2;
+    end
+        
+    % rgb means
+    for b = 1:3
+        regionFeatures(c, nf+b) = sum(spfeatures(spind, nf+2+b).*cpixelp);
+    end
+    % hsv
+    regionFeatures(c, nf+(4:6)) = rgb2hsv(regionFeatures(c, nf+(1:3)));
+    
+    % y and x locs
+    regionFeatures(c, nf+7) = sum(spfeatures(spind, nf+7).*cpixelp);
+    regionFeatures(c, nf+8) = sum(spfeatures(spind, nf+8).*cpixelp);
+    
+    % get the values that pertain to this region
+    rhue = hue(cinds{c});
+    rsat = sat(cinds{c});
+    rx = xim(cinds{c});
+    ry = yim(cinds{c});
+    redge = edgeim(cinds{c});
+    npix = length(cinds{c});
+    
+    % hue and sat histograms
+    nf = nf+8;
+    hue_histogram = (hist(rhue, [0.1:0.2:0.9]) + 0.01)/(length(rhue)+0.05);    
+    regionFeatures(c, nf+(1:5)) = hue_histogram / sum(hue_histogram);
+    regionFeatures(c, nf+6) = -1*sum(hue_histogram.*log(hue_histogram)) / log(length(hue_histogram));
+    sat_histogram = (hist(rsat, [0.167:0.333:0.833]) + 0.01)/(length(rsat)+0.03); 
+    regionFeatures(c, nf+(7:9)) = sat_histogram / sum(sat_histogram);
+    regionFeatures(c, nf+10) = -1*sum(sat_histogram.*log(sat_histogram)) / log(length(sat_histogram));
+    
+    % location - 10% and 90% percentiles of y and x
+    sorty = sort(ry);
+    regionFeatures(c, nf+11) = sorty(ceil(npix/10));
+    regionFeatures(c, nf+12) = sorty(ceil(9*npix/10));
+    sortx = sort(rx);
+    regionFeatures(c, nf+13) = sortx(ceil(npix/10));
+    regionFeatures(c, nf+14) = sortx(ceil(9*npix/10));    
+    
+    % center of edginess y and x
+    if regionFeatures(c, nf+11)==regionFeatures(c, nf+12)
+        regionFeatures(c, nf+15) = 0.5;
+    else
+        center_y = sum(redge.*ry) / sum(redge);
+        regionFeatures(c, nf+15) = sum((ry < center_y).*ry)/sum(ry);
+    end
+    if regionFeatures(c, nf+13)==regionFeatures(c, nf+14)
+        regionFeatures(c, nf+16) = 0.5;
+    else
+        center_x = sum(redge.*rx) / sum(redge);
+        regionFeatures(c, nf+16) = sum((rx < center_x).*rx)/sum(rx);
+    end    
+
+    % num superpixels, % of image area
+    regionFeatures(c, nf+17) = length(spind);
+    regionFeatures(c, nf+18) = npix / width / height;
+    
+    % polygon: num sides, area ratio
+    try
+        [polyi, polya] = convhull(rx, ry);
+        regionFeatures(c, nf+19) = length(polyi)-1;
+        regionFeatures(c, nf+20) = npix / (polya*width*height);
+    catch
+        regionFeatures(c, nf+(19:20)) = [4 0.75];
+    end
+
+    % whether contiguous
+    regionFeatures(c, nf+21) = 1;
+    for s = 1:length(spind)
+        isadj = imsegs.adjmat(setdiff(spind, spind(s)), spind(s));
+        if sum(isadj) == 0
+            regionFeatures(c, nf+21) = 0;         
+            break;
+        end
+    end
+
+    % vanishing point features
+    nf = nf + 21;
+    region_center = [sorty(ceil(npix/2)) sortx(ceil(npix/2))];  
+
+    rbounds = [sortx(1) sortx(end) 1-sorty(end) 1-sorty(1)];
+    regionFeatures(c, nf+(1:16)) = ...
+        APPvp2regionFeatures(spind, vpdata, region_center, rbounds, imsegs);
+
+    % y-location with respect to estimated horizon
+    if ~isnan(vpdata.hpos)
+        % location - 10% and 90% percentiles of y and x
+        regionFeatures(c, nf+17) = regionFeatures(c, 48) - (1-vpdata.hpos); % bottom 10 pct wrt horizon
+        regionFeatures(c, nf+18) = regionFeatures(c, 49) - (1-vpdata.hpos); % top 10 pct wrt horizon
+        % 1 -> completely under horizon, 2-> straddles horizon, 3-> completely above horizon
+        regionFeatures(c, nf+19) = (regionFeatures(c, nf+20)>0) + (regionFeatures(c, nf+21)>0) + 1;
+    else % horizon was not estimated with high confidence
+        regionFeatures(c, nf+(17:18)) = regionFeatures(c, [48:49])-0.5;
+        regionFeatures(c, nf+19) = 4;  % signifies no data-estimated horizon
+    end
+    
+    [h w] = size(image);
+    region_center(1) = region_center(1) - 0.5;
+    region_center(2) = region_center(2) - 0.5;    
+    regionFeatures(c, nf+(20:38)) = ...
+        APPgetVpFeatures(vpdata.spinfo(spind), vpdata.lines, region_center, [h w]);    
+      
+end

SUN_source_code_v1/code/GeometricContext_dhoiem/src/geom/APPgetSegmentInds.m

@@ -0,0 +1,8 @@
+function sinds = APPgetSegmentInds(imsegs);
+% Gets pixel indices for each superpixel in imsegs
+
+ns = imsegs.nseg;
+sinds = cell(ns, 1);
+for s = 1:ns
+    sinds{s} = find(imsegs.segimage==s);
+end

SUN_source_code_v1/code/GeometricContext_dhoiem/src/geom/APPgetSpData.m

@@ -0,0 +1,106 @@
+function spdata = APPgetSpData(image, doogFilters, textonFilters, imsegs)
+% spdata = APPgetSpData(image, doogFilters, textonFilters, imsegs)
+%
+% Gets the features and data corresponding to the superpixels given by
+% imsegs.
+% features:
+%   1-12: mean absolute filter response of diff of oriented Gaussian filters
+%   13: mean of 1-12
+%   14: argmax of 1-12
+%   15: max-median of 1-12
+%   possibly texton features (15+1:15+nTextons+2)
+%   16-18: mean rgb values
+%   19-21: hsv conversion from mean rgb values
+%   22-23: mean x and y locations
+%
+% Input:
+%   image: rgb image to be analyzed
+%   doogFilters: filters for texture (could be empty)
+%   textonFilters: filters for texture (could be empty)
+%   imsegs: superpixel structure
+% Output:
+%   spdata: structure for data corresponding to each superpixel
+%
+% Copyright(C) Derek Hoiem, Carnegie Mellon University, 2005
+% Current Version: 1.0  09/30/2005
+      
+nAngles = size(doogFilters, 3);
+        
+% compute texture responses
+grayim = rgb2gray(image);
+    
+%disp(num2str(size(image, 1)*size(image, 2)*nAngles /1024/1024*8))
+orientationImages = zeros(size(image, 1), size(image, 2), nAngles);
+% get and record the filter responses for each angle
+for (i=1:nAngles)        
+    orientationImages(:, :, i) = abs(conv2(grayim,doogFilters(:, :, i),'same')-grayim);        
+end
+%spdata.orientationImages = orientationImages;
+
+textonImages = compute_texton_response(grayim, textonFilters);
+nTextons = numel(textonFilters);
+
+[height, width, nb] = size(image);
+
+% features: angle response peaks, mean angle response, angle with 
+% largest response, dominance of largest filter, mean abs texton
+% repsonses, largest texton response, dominance of largest response, 
+% mean of rgb hsv x y
+nfeatures = nAngles + 3 + nTextons + 6 + 2;
+if nTextons > 0
+    nfeatures = nfeatures + 2;
+end
+
+% for each segmentation
+for i = 1:length(imsegs)
+    
+    nseg = imsegs(i).nseg;
+    spdata(i).npixels = imsegs(i).npixels;
+    spdata(i).adjmat = imsegs(i).adjmat;
+    
+    features = zeros(nseg, nfeatures);
+               
+    % oriented filters
+    maar = zeros(nseg, nAngles);
+    for a = 1:nAngles
+        maar(:, a) = APPgetSpMeans(imsegs(i), orientationImages(:, :, a));
+    end
+    features(:, 1:nAngles) = maar;
+    features(:, nAngles+1) = mean(maar, 2);
+    [maxval, features(:, nAngles+2)] = max(maar, [], 2);
+    features(:, nAngles+3) = maxval - median(maar, 2);    
+    spdata(i).orientation = maar;
+    spdata(i).edginess = mean(orientationImages, 3);
+    clear orientationImages;
+    
+    % textons    
+    cf = nAngles+3;
+    for t = 1:nTextons
+        features(:, cf+t) = APPgetSpMeans(imsegs(i), textonImages(:, :, t));
+    end
+    cf = cf + nTextons;
+    if nTextons>0
+        [maxval, features(:, cf+1)] = max(features(:, cf+1:cf+nTextons), [], 2);
+        features(:, cf+2) = maxval - median(features(:, cf+1:cf+nTextons), 2); 
+        clear textonImages;
+        cf = cf + 2;
+    end            
+    
+    % color
+    rgb = zeros(nseg, 3);
+    for b = 1:3
+        rgb(:, b) = APPgetSpMeans(imsegs(i), image(:, :, b));
+    end
+    features(:, cf + (1:3)) = rgb;
+    features(:, cf + (4:6)) = rgb2hsv(rgb);
+    
+    % location
+    cf = cf + 6;
+    yim = 1-repmat(((0:height-1)/(height-1))', 1, width);
+    xim = repmat(((0:width-1)/(width-1)), height, 1);
+    features(:, cf+1) = APPgetSpMeans(imsegs(i), yim);
+    features(:, cf+2) = APPgetSpMeans(imsegs(i), xim);
+    spdata(i).features = features;    
+end
+    
+    

SUN_source_code_v1/code/GeometricContext_dhoiem/src/geom/APPgetSpInds.m

@@ -0,0 +1,8 @@
+function sinds = APPgetSpInds(imsegs);
+% Gets pixel indices for each superpixel in imsegs
+
+ns = imsegs.nseg;
+sinds = cell(ns, 1);
+for s = 1:ns
+    sinds{s} = find(imsegs.segimage==s);
+end

SUN_source_code_v1/code/GeometricContext_dhoiem/src/geom/APPgetSpIndsOld.m

@@ -0,0 +1,33 @@
+function cinds = APPgetSpIndsOld(map, imsegs);
+% Get pixel indices for each superpixel
+
+nc = max(map(:));
+cinds(nc) = struct('inds', [], 'count', 0);
+
+t1 = cputime;
+for c = 1:nc
+    spind = find(map==c);
+    nind = sum(imsegs.npixels(spind));
+    cinds(c).inds = zeros(nind, 1);
+    cinds(c).count = 0;
+end
+
+t2 = cputime;
+nseg = imsegs.nseg;
+for k = 1:nseg
+    ind = find(imsegs.segimage==k);
+    c = map(k);
+    cinds(c).inds(cinds(c).count+1:cinds(c).count+length(ind)) = ind;
+    cinds(c).count = cinds(c).count + length(ind);
+end
+
+for c = 1:length(cinds)
+    cinds(c).inds = cinds(c).inds(1:cinds(c).count);
+end
+%segimage = imsegs.segimage;
+%for k = 1:numel(segimage)
+%    c = map(segimage(k));
+%    cinds(c).count = cinds(c).count + 1;
+%    cinds(c).inds(cinds(c).count) = k;
+%end
+

SUN_source_code_v1/code/GeometricContext_dhoiem/src/geom/APPgetSpMeans.m

@@ -0,0 +1,24 @@
+function smeans = APPgetSpMeans(imseg, values)
+% smeans = APPgetSpMeans(imseg, values)
+% 
+% Computes the mean of values for each superpixel in imseg.
+%
+% imseg.{npixels(nseg), segimage, nseg} - the segmentation information
+% values - a matrix of values
+% smeans(nseg, 1) - the means of values for each segment
+
+smeans = zeros(imseg.nseg, 1);
+count = zeros(imseg.nseg, 1);
+segimage = imseg.segimage;
+nelements = numel(segimage);
+for n = 1:nelements
+    s = segimage(n);
+    if s~=0
+        smeans(s) = smeans(s) + values(n);
+        count(s) = count(s) + 1;
+    end
+end
+smeans = smeans ./ (count+ (count==0));
+
+
+    

SUN_source_code_v1/code/GeometricContext_dhoiem/src/geom/APPgetSpStats.m

@@ -0,0 +1,78 @@
+function imsegs = APPgetSpStats(imsegs)
+% imsegs = APPgetSpStats(imsegs)
+% Gets basic information about the superpixels
+%
+% Copyright(C) Derek Hoiem, Carnegie Mellon University, 2005
+% Current Version: 1.0  09/30/2005
+
+for ii = 1:length(imsegs)
+        
+	nseg = imsegs(ii).nseg;
+	segimage = imsegs(ii).segimage;
+	
+    imh = size(segimage, 1);
+    
+	adjmat = eye([nseg nseg], 'uint8');
+
+    % get adjacency
+    dx = uint8(segimage ~= segimage(:,[2:end end]));
+    dy = segimage ~= segimage([2:end end], :);
+            
+    ind1 = find(dy);
+    ind2 = ind1 + 1;
+    s1 = segimage(ind1);
+    s2 = segimage(ind2);
+    adjmat(s1 + nseg*(s2-1)) = 1;
+    adjmat(s2 + nseg*(s1-1)) = 1;
+            
+    ind3 = find(dx);
+    ind4 = ind3 + imh;
+    s3 = segimage(ind3);
+    s4 = segimage(ind4);
+    adjmat(s3 + nseg*(s4-1)) = 1;
+    adjmat(s4 + nseg*(s3-1)) = 1;  
+    
+
+%   slower code
+% 	[height, width] = size(segimage);
+% 	
+% 	for y = 1:height-1
+%         for x = 1:width-1
+%             s1 = segimage(y, x);
+%             s2 = segimage(y+1, x);
+%             s3 = segimage(y, x+1);
+%             if s1 > 0
+%                 npixels(s1) = npixels(s1) + 1;
+%                 if s2 > 0 
+%                     adjmat(s1, s2) = 1;            
+%                     adjmat(s2, s1) = 1;
+%                 end                
+%                 if s3 > 0
+%                     adjmat(s1, s3) = 1;
+%                     adjmat(s3, s1) = 1;
+%                 end
+%             end
+%         end
+% 	end
+% 	
+% 	x = width;
+% 	for y = 1:height
+%         s1 = segimage(y, x);
+%         if s1 > 0
+%             npixels(s1) = npixels(s1) + 1;
+%         end
+% 	end
+% 	
+% 	y = height;
+% 	for x = 1:width-1        
+%         s1 = segimage(y, x);
+%         if s1 > 0             
+%             npixels(s1) = npixels(s1) + 1;
+%         end
+% 	end
+
+    stats = regionprops(segimage, 'Area');
+    imsegs(ii).npixels = vertcat(stats(:).Area);
+	imsegs(ii).adjmat = logical(adjmat);
+    
+end

SUN_source_code_v1/code/GeometricContext_dhoiem/src/geom/APPgetVpFeatures.m

@@ -0,0 +1,21 @@
+function features = APPgetVpFeatures(spinfo, lines, rCenter, imsize)
+% Get the vanishing point features for superpixels defined by spinfo
+% spinfo(nSp).{lines(nLinesInSp)}
+% rCenter([y x]): region center wrt image center (-0.5 to 0.5)
+%
+% Copyright(C) Derek Hoiem, Carnegie Mellon University, 2005
+% Current Version: 1.0  09/30/2005
+
+features = zeros(1, 19); 
+
+num_blocks = length(spinfo);
+used_lines = zeros(size(lines, 1), 1);
+max_angle = pi/8;
+
+for i = 1:num_blocks
+    used_lines(spinfo(i).lines) = 1;
+end
+lines = lines(find(used_lines>0), :);
+num_lines = size(lines, 1);
+
+features(:) = APPlines2vpFeatures(lines, max_angle);

SUN_source_code_v1/code/GeometricContext_dhoiem/src/geom/APPimages2superpixels.m

@@ -0,0 +1,44 @@
+function imsegs = APPimages2superpixels(input_dir, ext, gt)
+% imsegs = APPimages2superpixels(input_dir, ext, gt)
+% Create the imsegs structure from a segmentation image
+%
+% INPUT: 
+% input_dir - The directory of segmentation images. Segments are denoted by
+% different colors.
+% ext - the extension of the segmentation image filenames
+% gt - an existing imsegs structure (or [] if none exists)
+% OUTPUT:
+% imsegs - image segmentation data (and sometimes ground truth)
+%
+% Example: imsegs = APPimages2superpixels('../images', 'pnm', [])
+%
+% Copyright(C) Derek Hoiem, Carnegie Mellon University, 2005
+% Current Version: 1.0  09/30/2005
+
+if isempty(gt)
+    files = dir([input_dir '/*.' ext]);
+    for f = 1:length(files)
+        gt(f).image_name = files(f).name;
+    end
+end
+           
+
+imsegs(length(gt)) = struct('imname', '', 'imsize', [0 0]);
+for f = 1:length(gt)
+    imname = gt(f).image_name;
+    disp(imname)
+    basename = strtok(imname, '.');
+    im = imread([input_dir '/' basename '.' ext]);
+    
+    im = double(im);
+    
+    imsegs(f).imname = [strtok(imname,'.') '.jpg'];
+    imsegs(f).imsize = size(im);
+    imsegs(f).imsize = imsegs(f).imsize(1:2);
+    im = im(:, :, 1) + im(:, :, 2)*256 + im(:, :, 3)*256^2;
+    [gid, gn] = grp2idx(im);
+    imsegs(f).segimage = uint16(reshape(gid, imsegs(f).imsize));
+    imsegs(f).nseg = length(gn);
+
+end
+imsegs = APPgetSpStats(imsegs);

SUN_source_code_v1/code/GeometricContext_dhoiem/src/geom/APPlines2vpFeatures.m

@@ -0,0 +1,120 @@
+function data = APPlines2vpFeatures(lines, max_angle)
+% APPlines2vpFeatures(lines, max_angle)
+% Computes vanishing point related features from straight lines
+% data is currently 19 elements, line histograms not used
+%
+% Copyright(C) Derek Hoiem, Carnegie Mellon University, 2005
+% Current Version: 1.0  09/30/2005
+
+nbins=0;
+data = zeros(nbins+19, 1);
+
+nLines = size(lines, 1);
+
+if nLines <= 1
+    data(nbins+(1:2)) = 0.5;
+    data(nbins+3) = 0;
+    data(nbins +(4:10)) = 0;
+    return;
+end
+
+a = lines(:, 5);
+x1 = lines(:, 1);
+y1 = lines(:, 3);
+x2 = lines(:, 2);
+y2 = lines(:, 4);
+r = lines(:, 6);
+
+slength = sqrt((x2-x1).^2 + (y2-y1).^2);
+
+xc = (x1+x2)/2;
+yc = (y1+y2)/2;
+
+m = (y2-y1)./(x2-x1+1E-10);
+
+a1 = atan(tan(a));
+
+
+adist = pdist(a, 'cityblock');
+%adist = mod(adist, pi/2) < max_angle;
+adist = adist < max_angle;
+adistM = squareform(adist);
+
+
+% get |m1-m2|/|x1-x2|, where the direction of x is perpendicular to m 
+parabins = zeros(8, 1);
+paracount = zeros(8, 1);
+parabins2 = zeros(8, 1);
+leftcount = 0.05;
+rightcount = 0.05;
+upcount = 0.05;
+downcount = 0.05;
+histx = [(-pi/2):(pi/8):(pi/2)]-pi/16;
+for i = 1:nLines    
+    bn = sum(a1(i) > histx);
+    if bn==9
+        bn = 1;
+    end
+
+    m1 = m(i);  x1 = xc(i);  y1 = yc(i); 
+    %disp(num2str([x1 y1]))
+    isvert = abs(sin(a(i))) > abs(cos(a(i)));
+    ishorz = abs(cos(a(i))) > abs(sin(a(i)));
+    for j = i+1:nLines
+        if adistM(i, j) 
+            sl = min(slength([i j]));
+            
+            m2 = m(j); x2 = xc(j);  y2 = yc(j);
+           
+            if ~(m1==m2 & (y2-y1)==m1*(x2-x1)) % check for colinearity
+                
+                xi = (y2-y1+m1*x1-m2*x2)/(m1-m2+1E-10);
+                yi = (-y1*m2+m1*y2-m1*m2*x2+m1*x1*m2)/(m1-m2+1E-10);                              
+                
+                if sqrt(xi.^2+yi.^2) > 1 | m1==m2
+                    parabins(bn) = parabins(bn) + sl;
+                end
+                paracount(bn) = paracount(bn) + sl;    
+                
+                if sqrt(xi.^2+yi.^2) > 3.5 | m1==m2
+                    parabins2(bn) = parabins2(bn) + sl;
+                end
+                
+                if isvert
+                    if yi > (y1+y2)/2
+                        upcount = upcount + sl;
+                    else
+                        downcount = downcount + sl;
+                    end
+                else
+                    if xi > (x1+x2)/2
+                        rightcount = rightcount + sl;
+                    else
+                        leftcount = leftcount + sl;
+                    end
+                end
+            end
+        end
+    end
+end
+
+ind = find(paracount>0);
+parabins(ind) = parabins(ind) ./ paracount(ind);
+parabins2(ind) = parabins2(ind) ./ paracount(ind);
+%data(1:nbins) = angle_hist;  % extent of different vanishing point directions
+%data(nbins+1) = angle_entropy; % measure of how many different vanishing points there may be
+data(1) = rightcount ./ (leftcount+rightcount); % differentiate between face right and face left
+data(2) = upcount ./ (upcount+downcount); % differentiate between face up and face down
+%data(3) = sum(slength); % total number of line pixels in region
+data(3) = mean(adist);  % percent of pairs of angles that are roughly parallel
+data(4:11) = parabins; % measure of "parallelness" at different angles
+data(12:19) = parabins2;
+
+%disp(['bins: ' num2str(data(1:nbins)')]);               
+%disp(['rand: ' num2str(data(nbins+1:nbins+5)')])
+%disp(['para: ' num2str(data(nbins+6:end)')])
+            
+            
+            
+
+

SUN_source_code_v1/code/GeometricContext_dhoiem/src/geom/APPsp2regions.m

@@ -0,0 +1,114 @@
+function [maps, rscores, Z] = APPsp2regions(segDensity, spdata, nSegments)
+% [maps, rscores, Z] = APPsp2regions(segDensity, spdata, nSegments)
+% Clusters the superpixels into segments according to pairwise likelihoods
+% given by segDensity
+%
+% Input:
+%   segDensity: pairwise sp likelihoods structure
+%   spdata: superpixel data and features structure
+%   nSegments: array containing the number of segments for each
+%              segmentation
+% Ouput:
+%   maps(nSp, nMaps): randomly generated clusterings according
+%                     to the distribution given by densities and features
+%   rscores: the average log likelihood for each region
+%   Z: the pairwise superpixel likelihood matrix
+%
+% Copyright(C) Derek Hoiem, Carnegie Mellon University, 2005
+% Current Version: 1.0  09/30/2005
+
+features = spdata.features;
+
+nSp = size(features, 1);
+nFeatures = size(features, 2);
+nDist = nSp*(nSp-1)/2;
+nMaps = length(nSegments);
+
+Z = APPgetPairwiseSuperpixelLikelihoods(features, segDensity);
+
+% convert Z to P(y1=y2 | |x1-x2|)
+Z = log(1./(1+exp(-Z)));
+
+maps = zeros(nSp, nMaps);
+for m = 1:nMaps
+    
+    num_clusters = nSegments(m);
+    if num_clusters > nSp
+        num_clusters = nSp;
+    end
+    % get random ordering of indices
+    pind = randperm(nSp);
+       
+    % assign cluster ids to first num_clusters clusters    
+    for i = 1:num_clusters
+        maps(pind(i), m) = i;       
+    end
+
+    % assign remaining clusters
+    % go forwards ...
+    for i = num_clusters+1:length(pind)
+        % compute P(c(i) = k | x) for each k
+        f = zeros(num_clusters, 1);
+        likelihoods = Z(pind(1:i-1), pind(i));            
+        for k = 1:num_clusters
+            sameinds = find(maps(pind(1:i-1), m)==k);         
+            f(k) = mean(likelihoods(sameinds));
+        end 
+       
+        [tmp, k] = max(f);
+        
+        % assign cluster and add log(P(ci = k | x, c))
+        maps(pind(i), m) = k;
+        %fact = repmat(-1, [i-1 1]);
+        %fact(find(maps(pind(1:i-1), m)==k))=1;
+
+    end
+    
+    %... and go backwards now using all cluster assignments
+    for pp = 2:2
+        %for i = num_clusters+1:length(pind)
+        for i = 1:length(pind) % allow initial assignments to be reassigned
+            % compute P(c(i) = k | x) for each k
+            f = zeros(num_clusters, 1);
+            likelihoods = Z(:, pind(i));            
+            for k = 1:num_clusters
+                sameinds = find(maps(:, m)==k);          
+                if length(sameinds) > 0
+                    f(k) = mean(likelihoods(sameinds));
+                end
+            end 
+	     
+            [tmp, k] = max(f);
+            
+            % assign cluster and add log(P(ci = k | x, c))
+            maps(pind(i), m) = k;
+            %fact = repmat(-1, [i-1 1]);
+            %fact(find(maps(pind(1:i-1), m)==k))=1;        
+        end
+    end
+    
+    currmap = maps(:, m);
+    nc = max(currmap);
+    for k = 1:nc
+        ninds = length(find(currmap==k));
+        while ninds == 0 & k < nc
+            inds = find(currmap>k);
+            currmap(inds) = currmap(inds)-1;
+            ninds = length(find(currmap==k));
+            nc = max(currmap);
+        end
+    end
+    maps(:, m) = currmap;
+    
+    if nargout > 1
+        rscores{m} = zeros(nc, 1);
+        for k = 1:nc
+            ind = find(currmap==k);
+            npairs = length(ind)*(length(ind)-1);
+            % average of average log-likelihoods
+            rscores{m}(k) = 1./(1+exp(-sum(sum(Z(ind, ind)))/npairs));
+        end
+    end
+
+end
+

SUN_source_code_v1/code/GeometricContext_dhoiem/src/geom/APPspInds2regionInds.m

@@ -0,0 +1,23 @@
+function rinds = APPspInds2RegionInds(map, sinds)
+% rinds = APPspInds2RegionInds(map, sinds)
+% Gets the sp in each region
+%
+% Copyright(C) Derek Hoiem, Carnegie Mellon University, 2005
+% Current Version: 1.0  09/30/2005
+
+nr = max(map);
+rinds = cell(nr, 1);
+for r = 1:nr
+    count = 0;
+    rs = find(map==r);
+    for k = 1:length(rs)
+        count = count + length(sinds{rs(k)});
+    end         
+    rinds{r} = zeros(count, 1);
+    
+    count = 0;
+    for k = 1:length(rs) 
+        rinds{r}(count+1:count+length(sinds{rs(k)})) = sinds{rs(k)};
+        count = count + length(sinds{rs(k)});
+    end
+end

SUN_source_code_v1/code/GeometricContext_dhoiem/src/geom/APPtestImage.m~

@@ -0,0 +1,133 @@
+function [labels, conf_map, maps, pmaps] = APPtestImage(image, imsegs, ...
+    vClassifier, hClassifier, segDensity)
+% [labels, conf_map, maps, pmaps] = APPtestImage(image, imsegs,
+%                                  vClassifier, hClassifier, segDensity)
+% 
+% Gets the geometry for a single image.
+%
+% Input:
+%   image: the image to process
+%   imsegs: the sp structure
+%   vClassifier: region classifier for main classes
+%   hClassifier: region classifier for vertical subclasses
+%   segDensity: density for superpixel clustering
+% Output:
+%   labels: structure containing labeling results for each image
+%   conf_map: the likelihoods for each sp for each class for each image
+%   maps: the segmentation region maps (from superpixels to regions)
+%   pmaps: probabilities for each region
+%
+% Copyright(C) Derek Hoiem, Carnegie Mellon University, 2005
+% Permission granted to non-commercial enterprises for
+% modification/redistribution under GNU GPL.  
+% Current Version: 1.0  09/30/2005
+
+
+% mix class must be the last class in each classifier
+
+%exclude mix class
+nvclasses = length(vClassifier.names)-1; 
+nhclasses = length(hClassifier.names)-1;
+
+[doog_filters, texton_data] = APPgetImageFilters;
+
+imsegs.seginds = APPgetSpInds(imsegs);
+
+% compute features
+spdata = APPgetSpData(image, doog_filters, texton_data.tim, imsegs);
+[spdata.hue, spdata.sat, tmp] = rgb2hsv(image);
+
+
+imsize = size(image);
+minEdgeLen = sqrt(imsize(1)^2+imsize(2)^2)*0.02;
+[vpdata.lines, vpdata.spinfo] = ...
+    APPgetLargeConnectedEdges(rgb2gray(image), minEdgeLen, imsegs);
+[vpdata.v, vpdata.vars, vpdata.p, vpdata.hpos] = ...
+    APPestimateVp(vpdata.lines, imsize(1:2), 0);
+
+% create multiple partitions
+num_partitions = [3 4 5 7 9 11 15 20 25];
+num_maps = length(num_partitions);
+maps = APPsp2regions(segDensity, spdata, num_partitions);                
+
+nsegs = imsegs.nseg;
+pV = zeros(nsegs, nvclasses);
+pH = zeros(nsegs, nhclasses);
+
+% compute the probability of each block having each possible label
+for m = 1:num_maps
+    
+    currMap = maps(:, m);  
+    
+    %cluster_image = get_cluster_overlay_s2(rgb2gray(image), currMap, imsegs.segimage);                                
+    %imwrite(cluster_image, ['../results/tmp/alley09.c.' num2str(max(currMap)) '.jpg'], 'Quality', 80);    
+    
+    currNSegments = max(currMap(:));
+    
+    regionFeatures = APPgetRegionFeatures(image, imsegs, currMap, (1:currNSegments), spdata, vpdata);    
+       
+    nregions = size(regionFeatures, 1);
+
+    % get probability of vertical classes P(y|x) for each region
+    tmpV = test_boosted_dt_mc(vClassifier, regionFeatures);
+    tmpV = 1 ./ (1+exp(-tmpV));    
+    
+    % get probability of horizontal classes P(y|x) for each region
+    tmpH = test_boosted_dt_mc(hClassifier, regionFeatures);  
+    tmpH = 1 ./ (1+exp(-tmpH));
+    
+    % normalize probabilities so that each is P(label|~mixed)P(~mixed)
+    % normalize probabilities and sum over maps
+    for r = 1:nregions
+        indices = find(currMap == r);  
+        tmpV(r, 1:end-1) = tmpV(r, 1:end-1) / sum(tmpV(r, 1:end-1));
+        tmpV(r, 1:end-1) = tmpV(r, 1:end-1) * (1-tmpV(r, end));
+        for c = 1:nvclasses        
+            pV(indices, c) = pV(indices, c) + tmpV(r, c);%*pYv(c, r);
+        end
+        tmpH(r, 1:end-1) = tmpH(r, 1:end-1) / sum(tmpH(r, 1:end-1));
+        tmpH(r, 1:end-1) = tmpH(r, 1:end-1) * (1-tmpH(r, end));
+        for c = 1:nhclasses       
+            pH(indices, c) = pH(indices, c) + tmpH(r, c);%*pYh(c, r);
+        end
+                                    
+    end
+
+end
+
+% re-normalize weighted vote from classifiers
+for s = 1:size(pV, 1)
+    pV(s, :) = pV(s, :) / sum(pV(s, :));
+end
+for s = 1:size(pH, 1)
+    pH(s, :) = pH(s, :) / sum(pH(s, :));
+end
+
+conf_map.vmap = pV;
+conf_map.hmap = pH;
+conf_map.vnames = vClassifier.names(1:end-1);
+conf_map.hnames = hClassifier.names(1:end-1);
+
+
+% get label for each block with confidence
+% total_labels = char(zeros(num_blocks, 7));
+labels.vert_labels = cell(nsegs, 1);
+labels.vert_conf = zeros(nsegs, 1);
+labels.horz_labels = cell(nsegs, 1);
+labels.horz_conf = zeros(nsegs, 1);
+for s = 1:nsegs
+    [labels.vert_conf(s), c] = max(pV(s, :));
+    labels.vert_labels(s) = vClassifier.names(c);
+    [labels.horz_conf(s), c] = max(pH(s, :));
+    labels.horz_labels(s) = hClassifier.names(c);        
+end
+
+[tmp, vlabels] = max(pV, [], 2);
+[tmp, hlabels] = max(pH, [], 2);
+
+if 0 
+[hy, estType] = geometry2horizon(imsegs, vlabels, hlabels, vpdata);
+
+labels.hy = 1-hy;
+labels.hestType = estType;
+end

SUN_source_code_v1/code/GeometricContext_dhoiem/src/geom/APPvp2horizon.m

@@ -0,0 +1,112 @@
+function [pos, tilt, conf, y, py] = APPvp2horizon(v, vars, p, imsize)
+% [pos, tilt, conf, y, py] = APPvp2horizon(v, vars, p, imsize)
+%
+% Estimates the horizon position based on the vanishing points. Doesn't
+% work well.
+%
+% Input: 
+% v - vanishing points from estimateVP
+% vars - variances on vanishing point estimates
+% p - memberships of lines in vp
+% imsize - the size of the grayscale image
+% Output:
+% pos - y position (0 is top of image) of horizon, NaN if cannot be found
+% tilt - the angle of the horizon line, NaN if not set
+%
+% Copyright(C) Derek Hoiem, Carnegie Mellon University, 2005
+% Current Version: 1.0  09/30/2005
+
+% find vanishing points that occur within image height (or close)
+ind = find([v(:, 2) > -0.25 & v(:, 2) < 1.25]);
+
+% do not consider vp with variance greater than varthresh
+varthresh = 0.005;
+ind(find(vars(ind) > varthresh)) = [];
+
+% do not consider vp with fewer than 6 lines (expected)
+memberthresh = 6;
+nmembers = sum(p(:, ind), 1);
+ind(find(nmembers < memberthresh)) = [];
+
+conf = length(ind);
+
+% if more than two vp are left, choose two with least variance
+%[tmp, ordering] = sort(vars(ind), 'ascend');
+%ind = ind(ordering(1:min(2, length(ordering))));
+
+v = v(ind, :);
+vars = vars(ind);
+
+% compute horizon position (if possible) and tilt (if possible)
+if length(ind)==0
+    pos = NaN;
+    tilt = NaN;
+    conf = NaN;
+elseif length(ind)>0
+
+    % change variables so variance is along y axis only
+    v(:, 1) = v(:, 1) - 0.5*imsize(2)/imsize(1);
+    v(:, 2) = v(:, 2) - 0.5;
+    for i = 1:length(ind)
+        vars(i) = vars(i)*v(i,2)^2 / (v(i,1)^2+v(i,2)^2);    
+    end    
+    pos = sum(v(:, 2) ./ vars') / sum(1./vars');
+%    pos = mean(v(:, 2));
+    
+%     pos = mean(v(:, 2));
+%     conf = std(v(:, 2)) * sqrt(length(ind) / (length(ind)-1));
+%     tilt = 0;
+
+%     disp(['vp: ' num2str(length(ind))])
+%     if length(ind)>2
+%         [p, stats] = robustfit(v(:,1),v(:,2));
+%         tilt = p(1);
+%     else
+%         [p, stats] = robustfit(v(:, 1), v(:, 2));         
+%         tilt = p(1);
+%     end
+%     conf = stats.se(2);
+%     pos = p(2);
+    %[pos, conf] = polyval(p, 0, S);
+    %pos = p(2);
+%    conf = mu(2);
+    %tilt = p(1);
+%     disp(num2str([pos+0.5 tilt conf]));
+        
+    % get distribution of horizon surrounding most likely position
+    if nargout > 3
+        y = [pos-0.25:0.005:pos+0.25];
+        py = zeros(size(y));
+        for i = 1:size(v, 1)
+            py = py + log(1 / sqrt(2*pi*vars(i))*exp(-1/2/vars(i)*(y-v(i,2)).^2));
+        end
+        py = exp(py);
+        py = py / sum(py);
+
+        y = y + 0.5;
+
+        % remove sampling points with very low probability
+        ind = find(py> (1E-4)/length(py));
+        y = y(ind);
+        py = py(ind);
+        py = py / sum(py);
+    end
+    
+    pos = pos + 0.5;
+    %tilt = NaN;    
+    
+    %figure(1), plot(y, py, 'r')    
+end
+
+
+% elseif length(ind)==1
+%     pos = 1-v(1, 2);
+%     tilt = NaN;
+% end
+% else % length(ind)==2
+%    midx = (imsize(2)/2/imsize(1));
+%    m = (v(1,2)-v(2,2)) / (v(1,1)-v(2,1));
+%    b = v(1,2) - m*v(1,1);
+%    pos = midx*m+b;
+%    tilt = atan(-m);
+% end

SUN_source_code_v1/code/GeometricContext_dhoiem/src/geom/APPvp2regionFeatures.m

@@ -0,0 +1,217 @@
+function features = APPvp2regionFeatures(sinds, vpdata, rcenter, rbounds, imsegs)
+% get the vanishing point features for a particular set of superpixels
+% INPUT:
+% sinds - the indices for the superpixels in the region
+% vpdata.{v, vars, p, hpos, lines, spinfo} - statistics from estimateVP over entire image
+%       spinfo - tells which lines each superpixel contains
+%       lines - [x1 x2 y1 y2 theta r] endpoint and parameters for each line
+% rcenter - center of the region [x y]; (0,0) is upper-left of image
+% rbounds - bounds of region [minx maxx miny maxy]; (0,0) is upper-left of image
+% imsegs - info about superpixelation
+% OUTPUT:
+% features
+% 1 - 8 : line orientation histogram (normalized, weighted by length)
+% 9     : entropy of line orientation histogram
+% 10    : (num line pixels) / sqrt(area)
+% 11    : (num line pixels with vertical vp membership) / sqrt(area)
+% 12    : (num line pixels with horizontal vp membership) / sqrt(area)
+% 13    : % of total line pixels with vertical membership
+% 14    : x-pos of vp on horizon - center (0 if none)
+% 15    : (y-pos of highest/lowest vertical vp - center) (0 if none)
+% 16    : center wrt horizon vp {left, right, surrounding, far left/right, no vp on horizon}
+%%%%%%%%%% 17-19 no longer used because ineffective
+% 17-19 : same as 14-16 but with vp estimated only from region
+% discrete features: 16
+%
+% Copyright(C) Derek Hoiem, Carnegie Mellon University, 2005
+% Current Version: 1.0  09/30/2005
+
+features = zeros(1, 16);
+
+% maximum variance for a vp to be considered reliable
+maxvpvar = 0.001;
+
+% min distance to be considered "far" 
+minfardist = 2.5; 
+
+% max y-value for vp to be considered horizon candidate
+maxhorzpos = 1.25;
+
+% select relevant parts of data to this region
+spinfo = vpdata.spinfo;
+lines = vpdata.lines;
+nseg = length(sinds);
+spinfo = spinfo(sinds);
+lineinds = union([spinfo(:).lines], []);
+lines = lines(lineinds, :);
+
+% arrange vp info
+nvp = size(vpdata.v, 1);
+imsize = imsegs.imsize;
+isvalidvp = ones(size(vpdata.vars));
+vpdata.p = vpdata.p(lineinds, :);
+[linevpconf, linevp] = max(vpdata.p, [], 2);
+%disp(num2str(size(lines, 1)))
+%disp(num2str(sum(vpdata.p, 1)))
+for i = 1:length(isvalidvp)
+    if isvalidvp(i) && sum(vpdata.p(:, i)) <= 3
+        isvalidvp(i) = 0;
+    end
+end
+%disp(num2str(isvalidvp))     
+
+
+% make vp relative to region center
+vpdata.v = vpdata.v - repmat([rcenter 1], nvp, 1);
+% vpdata.v(:, 1) = vpdata.v(:, 1) - imsize(2)/imsize(1)/2;
+% vpdata.v(:, 2) = vpdata.v(:, 2) - 1/2;
+
+% more line and area statistics
+nlines = size(lines, 1);
+nlinepixels = sum([spinfo(:).edge_count]);
+linelength = sqrt((lines(:, 1)-lines(:,2)).^2 + (lines(:, 3)-lines(:,4)).^2);
+rarea = sum(imsegs.npixels(sinds)) / prod(imsegs.imsize(1:2));
+
+% orientation histogram and entropy
+nbins = 8;
+bw = pi / nbins;
+%bincenters = [0 : bw : pi];
+binedges = [bw/2 : bw : pi-bw/2];
+lineangles = mod(lines(:,5), pi); % range from 0 to pi
+bins = zeros(nlines, 1);
+for k = 1:nlines
+    bins(k) = sum(lineangles(k) > binedges);
+end
+bins = bins + nbins*(bins==0);
+for k = 1:nbins
+    linehist(k) = sum(linelength(find(bins==k)));
+end
+if sum(linehist)==0
+    features(1:8) = 0;
+    features(9) = 1;
+else
+    linehist = linehist+1;
+    linehist = linehist / sum(linehist);
+    features(1:8) = linehist;
+    features(9) = -1 * sum(linehist .* log(linehist))/log(nbins);
+end
+
+% 10    : (num line pixels) / sqrt(area)
+features(10) = sum(nlinepixels) / sqrt(rarea);
+
+% % for vertical check that vanishing point has at least 75% confidence of
+% % being greater than 75 degrees
+%vertconf = 1 - normcdf(3.75, abs(vpdata.v(:, 2)'), sqrt(vpdata.vars));
+vertvp = find((abs(vpdata.v(:, 2)) > minfardist) & (vpdata.vars < maxvpvar)' & isvalidvp'); 
+horzvp = find((abs(vpdata.v(:, 2)) < maxhorzpos) & isvalidvp' & (vpdata.vars < maxvpvar)'); 
+
+% 11    : (num line pixels with vertical vp membership) / sqrt(area)
+features(11) = 0;
+for i = 1:length(vertvp)
+    vertlineinds = find(linevp==vertvp(i));
+    features(11) = features(11) + sum(linelength(vertlineinds));
+end
+features(11) = features(11) / sqrt(rarea);
+
+% 12    : (num line pixels with horizontal vp membership) / sqrt(area)
+featuers(12) = 0;
+for i = 1:length(horzvp)
+    horzlineinds = find(linevp==horzvp(i));
+    features(12) = features(12) + sum(linelength(horzlineinds));
+end
+features(12) = features(12) / sqrt(rarea);
+
+% 13    : % of total line pixels with vertical membership
+if linelength > 0
+    features(13) = features(11) / ( sum(linelength) / sqrt(rarea) );
+end
+
+% expected number of lines belonging to each vanishing point
+vpcount = sum(vpdata.p, 1);
+
+% 14    : x-pos of vp on horizon - center (0 if none)
+[tmp, maxind] = max(vpcount(horzvp));
+besthorzdist = vpdata.v(horzvp(maxind), 1);
+if ~isempty(besthorzdist)
+    features(14) = besthorzdist;
+end % else features(14) = 0
+
+% 15    : abs(y-pos of highest/lowest vertical vp - center) (0 if none)
+[tmp, maxind] = max(vpcount(vertvp));
+bestvertdist = vpdata.v(vertvp(maxind), 2);
+if ~isempty(bestvertdist)
+    features(15) = bestvertdist;
+end % else features(15) = 0
+
+% 16    : region pos wrt horizon vp {left, right, surrounding, far left/right, no vp on horizon}
+tmppos = besthorzdist + rcenter(1); % return to image coordinates
+if (isempty(besthorzdist)) % no vp on horizon
+    features(16) = 5; 
+elseif abs(besthorzdist) > minfardist % region far from vp (implies facing center)
+    features(16) = 4;
+elseif rbounds(2) < tmppos % region left of vp (implies facing right)
+    features(16) = 1;
+elseif rbounds(1) > tmppos % region right of vp (implies facing left)
+    features(16) = 2; 
+else  % region surrounds vp (implies mixed)
+    features(16) = 3;
+end
+
+
+% %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+% % COMPUTE NEW VP USING REGION ONLY DATA FOR 17-19
+% %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+% if ~isempty(lines)
+%     [vpdata.v, vpdata.vars, vpdata.p] = estimateVP(lines, imsize);
+% else
+%     vpdata.v = [0 0 1];
+%     vpdata.vars = [1];
+%     vpdata.p = [];
+% end
+% 
+% %vertconf = 1 - normcdf(3.75, abs(vpdata.v(:, 2)'), sqrt(vpdata.vars));
+% vertvp = find((abs(vpdata.v(:, 2)) > minfardist) & (vpdata.vars < maxvpvar)'); 
+% horzvp = find((abs(vpdata.v(:, 2)) < maxhorzpos) & (vpdata.vars < maxvpvar)'); 
+% vpcount = sum(vpdata.p, 1);
+% 
+% % 17    : x-pos of vp on horizon - center (0 if none)
+% [tmp, maxind] = max(vpcount(horzvp));
+% besthorzdist = vpdata.v(horzvp(maxind), 1);
+% if ~isempty(besthorzdist)
+%     features(17) = besthorzdist;
+% end % else features(17) = 0
+% 
+% % 18    : abs(y-pos of highest/lowest vertical vp - center) (0 if none)
+% [tmp, maxind] = max(vpcount(vertvp));
+% bestvertdist = vpdata.v(vertvp(maxind), 2);
+% if ~isempty(bestvertdist)
+%     features(18) = bestvertdist;
+% end % else features(18) = 0
+% 
+% % 19    : region pos wrt horizon vp {left, right, surrounding, far left/right, no vp on horizon}
+% tmppos = besthorzdist + rcenter(1); % return to image coordinates
+% if (isempty(besthorzdist)) % no vp on horizon
+%     features(19) = 5; 
+% elseif abs(besthorzdist) > minfardist % region far from vp (implies facing center)
+%     features(19) = 4;
+% elseif rbounds(2) < tmppos % region left of vp (implies facing right)
+%     features(19) = 1;
+% elseif rbounds(1) > tmppos % region right of vp (implies facing left)
+%     features(19) = 2; 
+% else  % region surrounds vp (implies mixed)
+%     features(19) = 3;
+% end
+
+%disp(num2str(features(14:19)))
+
+% % 17    : region pos wrt horizon {below, surrounding, above}
+% tmpos = vpdata.hpos;
+% if (tmppos > rbounds(3)) && (tmppos < rbounds(4)) % region surrounds horizon (implies vertical)
+%     features(17) = 2;
+% elseif rbounds(3) < tmppos % region below horizon (implies ground or vertical)
+%     features(16) = 1;
+% elseif rbounds(4) > tmppos % region above horizon (implies sky or vertical)
+%     features(16) = 2;    
+% end
+
+

SUN_source_code_v1/code/GeometricContext_dhoiem/src/ijcv06/hsWheel.m

@@ -0,0 +1,21 @@
+function im = hsWheel(hrange, srange, wrad)
+
+im = zeros(2*wrad, 2*wrad);
+
+for ty = 1:2*wrad
+    for tx = 1:2*wrad
+        y = ty-1/2 - wrad;
+        x = tx-1/2 - wrad;
+        r = sqrt(y^2 + x^2);
+        if r <= wrad
+            theta = atan2(x, y);
+            theta = theta + (theta<0)*2*theta;
+            [tmp, sind] = min(abs(srange-r/wrad));
+            [tmp, hind] = min(abs(hrange-theta/2/pi));
+            im(ty, tx) = (hind-1)*numel(hrange) + sind;
+        end
+    end
+end
+
+
+

SUN_source_code_v1/code/GeometricContext_dhoiem/src/ijcv06/ijcvColorFigureScript.m

@@ -0,0 +1,70 @@
+% ijcvLocationFigureScript
+
+outdir = '/IUS/vmr20/dhoiem/data/ijcv06/results';
+
+nb = 50; % nbins
+
+vimages = ones(nb, nb, 3);
+himages = ones(nb, nb, 5);    
+
+for f = 1:numel(imsegs)
+
+    segimage = imsegs(f).segimage;
+    im = im2double(imread([imdir '/' imsegs(f).imname]));
+    [hue, sat, val] = rgb2hsv(im);
+    hue = max(ceil(hue*nb),1);
+    sat = max(ceil((1-sat)*nb),1);
+    
+    vlab = imsegs(f).vert_labels(imsegs(f).segimage);
+    hlab = imsegs(f).horz_labels(imsegs(f).segimage);        
+    
+    for k = 1:numel(segimage)
+        if vlab(k)~=0
+            vimages(sat(k), hue(k), vlab(k)) = vimages(sat(k), hue(k), vlab(k)) + 1;
+        end
+        if hlab(k)~=0
+            himages(sat(k), hue(k), hlab(k)) = himages(sat(k), hue(k), hlab(k)) + 1;
+        end            
+    end   
+        
+    if mod(f, 50)==0
+        disp(num2str(f))
+    end
+end
+
+probcolor = sum(vimages, 3);
+probcolor = probcolor / sum(probcolor(:));
+probcolor = probcolor / max(probcolor(:));
+
+
+vimages = vimages ./ repmat(sum(vimages, 3), [1 1 3]);
+himages = himages ./ repmat(sum(himages, 3), [1 1 5]);
+
+hueim = repmat([1:nb]/nb, [nb 1]);
+satim = repmat(1-[1:nb]'/nb, [1 nb]);
+
+imwrite(hsv2rgb(imresize(cat(3, hueim, satim, probcolor),1)), [outdir '/color_prob.jpg'], 'Quality', 100);
+imwrite(hsv2rgb(imresize(cat(3, hueim, satim, ones(nb,nb)),1)), [outdir '/color_full.jpg'], 'Quality', 100);
+for v = 1:3
+    imwrite(hsv2rgb(imresize(cat(3, hueim, satim, vimages(:, :, v)),1)), ...
+        [outdir '/vcol' num2str(v) '.jpg'], 'Quality', 100);
+end
+
+for h = 1:5
+    imwrite(hsv2rgb(imresize(cat(3, hueim, satim, himages(:, :, h)),1)), ...
+        [outdir '/hcol' num2str(h) '.jpg'], 'Quality', 100);
+end
+
+% [tmp, bestv] = max(vimages, [], 3);
+% [tmp, besth] = max(himages, [], 3);
+% colimseg.nseg = 7;
+% colimseg.segimage = (bestv==1) + (bestv==2).*(1+besth) + 7*(bestv==3);
+% for k = 1:7
+%     colimseg.npixels(k) = sum(colimseg.segimage(:)==k);
+% end
+% lim = APPgetLabeledImage(ones(200,200, 3), colimseg, ...
+%     {'000', '090', '090', '090', '090', '090', 'sky'}, ones(7, 1), ...
+%     {'---', '045', '090', '135', 'por', 'sol', '---'}, ones(7, 1));
+% imwrite(lim, [outdir '/labeledcol.jpg'], 'Quality', 100);
+% lim2 = (lim>0).*vimages(:, :, [2 1 3]);
+% imwrite(lim2, [outdir '/labeledcol.jpg'], 'Quality', 100);

SUN_source_code_v1/code/GeometricContext_dhoiem/src/ijcv06/ijcvColorFigureScript.m~

@@ -0,0 +1,70 @@
+% ijcvLocationFigureScript
+
+outdir = '/IUS/vmr20/dhoiem/data/ijcv06/results';
+
+nb = 50; % nbins
+
+vimages = ones(nb, nb, 3);
+himages = ones(nb, nb, 5);    
+
+for f = 1:numel(imsegs)
+
+    segimage = imsegs(f).segimage;
+    im = im2double(imread([imdir '/' imsegs(f).imname]));
+    [hue, sat, val] = rgb2hsv(im);
+    hue = max(ceil((1-hue)*nb),1);
+    sat = max(ceil(sat*nb),1);
+    
+    vlab = imsegs(f).vert_labels(imsegs(f).segimage);
+    hlab = imsegs(f).horz_labels(imsegs(f).segimage);        
+    
+    for k = 1:numel(segimage)
+        if vlab(k)~=0
+            vimages(sat(k), hue(k), vlab(k)) = vimages(sat(k), hue(k), vlab(k)) + 1;
+        end
+        if hlab(k)~=0
+            himages(sat(k), hue(k), hlab(k)) = himages(sat(k), hue(k), hlab(k)) + 1;
+        end            
+    end   
+        
+    if mod(f, 50)==0
+        disp(num2str(f))
+    end
+end
+
+probcolor = sum(vimages, 3);
+probcolor = probcolor / sum(probcolor(:));
+probcolor = probcolor / max(probcolor(:));
+
+
+vimages = vimages ./ repmat(sum(vimages, 3), [1 1 3]);
+himages = himages ./ repmat(sum(himages, 3), [1 1 5]);
+
+hueim = repmat([1:nb]/nb, [nb 1]);
+satim = repmat(1-[1:nb]'/nb, [1 nb]);
+
+imwrite(hsv2rgb(imresize(cat(3, hueim, satim, probcolor),1)), [outdir '/color_prob.jpg'], 'Quality', 100);
+imwrite(hsv2rgb(imresize(cat(3, hueim, satim, ones(nb,nb)),1)), [outdir '/color_full.jpg'], 'Quality', 100);
+for v = 1:3
+    imwrite(hsv2rgb(imresize(cat(3, hueim, satim, vimages(:, :, v)),1)), ...
+        [outdir '/vcol' num2str(v) '.jpg'], 'Quality', 100);
+end
+
+for h = 1:5
+    imwrite(hsv2rgb(imresize(cat(3, hueim, satim, himages(:, :, h)),1)), ...
+        [outdir '/hcol' num2str(h) '.jpg'], 'Quality', 100);
+end
+
+[tmp, bestv] = max(vimages, [], 3);
+[tmp, besth] = max(himages, [], 3);
+colimseg.nseg = 7;
+colimseg.segimage = (bestv==1) + (bestv==2).*(1+besth) + 7*(bestv==3);
+for k = 1:7
+    colimseg.npixels(k) = sum(colimseg.segimage(:)==k);
+end
+lim = APPgetLabeledImage(ones(200,200, 3), locimseg, ...
+    {'000', '090', '090', '090', '090', '090', 'sky'}, ones(7, 1), ...
+    {'---', '045', '090', '135', 'por', 'sol', '---'}, ones(7, 1));
+imwrite(lim, [outdir '/labeledloc.jpg'], 'Quality', 100);
+lim2 = (lim>0).*vimages(:, :, [2 1 3]);
+imwrite(lim2, [outdir '/labeledloc2.jpg'], 'Quality', 100);