committing after hiatus from code...

all analysis are now shadered

config.refindx

@@ -1,46 +1,76 @@
 <!-- THIS FILE NEEDS TO GO IN THE APPLICATION /data/ folder -->
 
 <config>
-    <mode>drawing</mode>
+    <mode>analysis</mode>
-	<camera>
-		<id>1</id>
-		<width>640</width>
-		<height>480</height>
-	</camera>
-	<display>
-		<fps>30</fps>
-    </display>
-	<locale>
-		<name>SWANSEA</name>
-	</locale>
 
-    <analysis_NUM_RUN>
+<camera>
-        <NUM_RUN_shadowscapes>          3      </NUM_RUN_shadowscapes>
+    <id>1</id>
-        <NUM_RUN_relaxrate>             3      </NUM_RUN_relaxrate>
+    <width>640</width>
-        <NUM_RUN_iresponse>             3      </NUM_RUN_iresponse>
+    <height>480</height>
-        <NUM_RUN_shapefromshading>      3      </NUM_RUN_shapefromshading>
+</camera>
-        <NUM_RUN_strobe>                5      </NUM_RUN_strobe>
-        <NUM_RUN_camnoise>              5      </NUM_RUN_camnoise>
-        <NUM_RUN_colorsingle>           5      </NUM_RUN_colorsingle>
-        <NUM_RUN_colormulti>            5      </NUM_RUN_colormulti>
-        <NUM_RUN_diffnoise>             3      </NUM_RUN_diffnoise>
-    </analysis_NUM_RUN>
 
-    <analysis_time>
+<display>
-        <acquiretime_shadowscapes>      30      </acquiretime_shadowscapes>
+    <fps>30</fps>
-        <acquiretime_relaxrate>         30      </acquiretime_relaxrate>
+</display>
-        <acquiretime_iresponse>         30      </acquiretime_iresponse>
+
-        <acquiretime_shapefromshading>  30      </acquiretime_shapefromshading>
+<locale>
-        <acquiretime_strobe>            30      </acquiretime_strobe>
+    <name>FUTURE</name>
-        <acquiretime_camnoise>          30      </acquiretime_camnoise>
+</locale>
-        <acquiretime_colorsingle>       40      </acquiretime_colorsingle>
+
-        <acquiretime_colormulti>        40      </acquiretime_colormulti>
+<analysis_NUM_RUN>
-        <acquiretime_diffnoise>         30      </acquiretime_diffnoise>
+    <NUM_RUN_shadowscapes>          1      </NUM_RUN_shadowscapes>
-    </analysis_time>
+    <NUM_RUN_relaxrate>             1     </NUM_RUN_relaxrate>
+    <NUM_RUN_iresponse>             1      </NUM_RUN_iresponse>
+    <NUM_RUN_shapefromshading>      1      </NUM_RUN_shapefromshading>
+    <NUM_RUN_strobe>                1      </NUM_RUN_strobe>
+    <NUM_RUN_camnoise>              1      </NUM_RUN_camnoise>
+    <NUM_RUN_colorsingle>           1      </NUM_RUN_colorsingle>
+    <NUM_RUN_colormulti>            1      </NUM_RUN_colormulti>
+    <NUM_RUN_diffnoise>             1      </NUM_RUN_diffnoise>
+</analysis_NUM_RUN>
+
+<analysis_time>
+    <acquiretime_shadowscapes>      7     </acquiretime_shadowscapes>
+    <acquiretime_relaxrate>         10      </acquiretime_relaxrate>
+    <acquiretime_iresponse>         30      </acquiretime_iresponse>
+    <acquiretime_shapefromshading>  30      </acquiretime_shapefromshading>
+    <acquiretime_strobe>            30      </acquiretime_strobe>
+    <acquiretime_camnoise>          30      </acquiretime_camnoise>
+    <acquiretime_colorsingle>       40      </acquiretime_colorsingle>
+    <acquiretime_colormulti>        15      </acquiretime_colormulti>
+    <acquiretime_diffnoise>         30      </acquiretime_diffnoise>
+</analysis_time>
+
+<algorithms>
+    <vertices_per_frame>1000</vertices_per_frame>
+    <pixel_per_vertex>4</pixel_per_vertex>
+    
+    <colormulti>
+        <algo>2</algo>
+        <scale>2</scale>
+        <draw_style>3</draw_style>
+        <line_width>2</line_width>
+    </colormulti>
     
     <relaxrate>
-        <treshold>51</treshold>
+        <algo>4</algo>
-        <maxblobs>25</maxblobs>
+        <scale>600</scale>        
+        <draw_style>2</draw_style>
+        <line_width>4</line_width>
     </relaxrate>
     
+    <shadowscapes>
+        <algo>1</algo>
+        <scale>650</scale>
+        <draw_style>1</draw_style>
+        <line_width>1</line_width>
+    </shadowscapes>        
+
+</algorithms>
+
+<relaxrate>
+<treshold>51</treshold>
+<maxblobs>25</maxblobs>
+</relaxrate>
+
 </config>

dviid/hessian.cl

@@ -0,0 +1,372 @@
+/*
+ ~ copyright (c) 2011 dviid
+ ~ contact: dviid@labs.ciid.dk 
+ 
+ + redistribution and use in source and binary forms, with or without
+ + modification, are permitted provided that the following conditions
+ + are met:
+ +  > redistributions of source code must retain the above copyright
+ +    notice, this list of conditions and the following disclaimer.
+ +  > redistributions in binary form must reproduce the above copyright
+ +    notice, this list of conditions and the following disclaimer in
+ +    the documentation and/or other materials provided with the
+ +    distribution.
+ 
+ + THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ + "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ + LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+ + FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+ + COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+ + INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+ + BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
+ + OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
+ + AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ + OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
+ + OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ + SUCH DAMAGE.
+ 
+ ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+ */
+
+const sampler_t smp = CLK_NORMALIZED_COORDS_FALSE | CLK_ADDRESS_CLAMP_TO_EDGE | CLK_FILTER_NEAREST;
+
+const sampler_t smp_adrs = CLK_NORMALIZED_COORDS_FALSE | CLK_ADDRESS_CLAMP | CLK_FILTER_NEAREST;
+
+
+float box_integral(read_only image2d_t src, int width, int height, int row, int col, int nbrrows, int nbrcols)
+{
+    float A = 0.0f;
+    float B = 0.0f;
+    float C = 0.0f;
+    float D = 0.0f;
+    
+    int r0 = min(row, height) - 1;
+    int c0 = min(col, width) - 1;
+    int r1 = min(row + nbrrows, height) - 1;
+    int c1 = min(col + nbrcols, width) - 1;
+    
+    A = read_imagef(src, smp, (int2)(c0, r0)).x;
+    B = read_imagef(src, smp, (int2)(c1, r0)).x;
+    C = read_imagef(src, smp, (int2)(c0, r1)).x;
+    D = read_imagef(src, smp, (int2)(c1, r1)).x;
+    
+    return max(0.0f, A - B - C + D);
+    
+}
+
+
+__kernel void hessian_det(
+                          read_only image2d_t src,
+                          int width,
+                          int height,
+                          write_only image2d_t determinant,
+                          write_only image2d_t laplacians,
+                          int layer_width,
+                          int layer_height,
+                          int step,
+                          int filter)
+{
+    int l, w, b;
+    float Dxx, Dxy, Dyy, inverse;
+    
+    int idx = get_global_id(0);
+    int idy = get_global_id(1);
+    
+    w = filter;
+    l = w / 3;
+    b = (w - 1) / 2 + 1
+    inverse = 1.0f / (w * w);
+    
+    int c = idx * step;
+    int r = idy * step;
+    
+    if(r >= height || c >= width) return;
+    
+    Dxx = box_integral(src, width, height, r - l + 1, c - b, 2 * l - 1, w) -
+          box_integral(src, width, height, r - l + 1, c - l / 2, 2 * l - 1, l) * 3;
+    
+    Dxy = box_integral(src, width, height, r - l, c + 1, l, l) +
+          box_integral(src, width, height, r + 1, c - l, l, l) -
+          box_integral(src, width, height, r - 1, c - l, l, l) -
+          box_integral(src, widht, height, r + 1, c + 1, l, l);
+    
+    DYY = box_integral(src, width, height, r - b, c - l + 1, w, 2 * l - 1) -
+          box_integral(src, width, height, r - l / 2, c - l + 1, l, 2 * l -1) * 3;
+    
+    Dxx += inverse; 
+    Dxy += inverse; 
+    Dyy += inverse; 
+    
+    float4 det = {0.0f, 0.0f, 0.0f, 0.0f};
+    det.x = (Dxx * Dyy - 0.81f * Dxy * Dxy);
+    
+    int4 lap = {0, 0, 0, 0};
+    lap.x = (Dxx + Dyy >= 0 ? 1 : 0);
+    
+    write_imagef(determinant, (int2)(idx, idy), det);
+    write_imagef(laplacians, (int2)(idx, idy), lap);
+    
+}
+
+int pop_laplacian(read_only image2d_t layer, int c, int r, int width)
+{
+    int lap;
+    lap = read_imagei(layer, smp_adrs, (int2)(c,r)).x;
+    return lap;
+}
+
+float pop_response(read_only image2d_t layer, int c, int r, int width, int scale)
+{
+    float resp;
+    resp = read_imagef(layer, smp_adrs, (int2)(c*scale, r*scale)).x;
+    return resp;
+}
+
+bool interpolate_extremum(
+                          int r,
+                          int c,
+                __global int* pts_cnt;
+                      float2* pos,
+                       float* det_scale
+                         int* laplacian,
+          read_only image2d_t t,
+                          int t_width,
+                          int t_height,
+                          int t_step,
+          read_only image2d_t m,
+          read_only image2d_t mlaplacian,
+                          int m_width,
+                          int m_height,
+                          int m_filter,
+          read_only image2d_t b,
+                          int b_width,
+                          int b_height,
+                          int b_filter
+                          )
+{
+    
+    // 3D derivatives
+    
+    int mscale = (m_width / m_height);
+    int bscale = (b_width / b_height);
+    
+    float Dx, Dy, Dz;
+    
+    Dx = (pop_response(m, c+1, r,   m_width, mscale) -
+          pop_response(m, c-1, r,   m_width, mscale)) / 2.0f;
+    Dy = (pop_response(m, c,   r+1, m_width, mscale) -
+          pop_response(m, c,   r-1, m_width, mscale)) / 2.0f;
+    
+    Dz = (pop_response(t, c, r, t_width, 1) - 
+          pop_response(b, c, r, b_width, bscale)) / 2.0f;
+          
+    // inverse hessian
+    
+    float v, Dxx, Dyy, Dzz, Dxy, Dxz, Dyz;
+    
+    v = pop_response(m, r, c, m_width, mscale);
+    
+    Dxx = pop_response(m, c+1, r,   m_width, mscale) + 
+          pop_response(m, c-1, r,   m_width, mscale) - 2.0f * v;
+    
+    Dyy = pop_response(m, c,   r+1, m_width, mscale) +
+          pop_response(m, c,   r-1, m_width, mscale) - 2.0f * v;
+        
+    Dxy = (pop_response(m, c+1, r+1, m_width, mscale) -
+           pop_response(m, c-1, r+1, m_width, mscale) -
+           pop_response(m, c+1, r-1, m_width, mscale) +
+           pop_response(m, c-1, r-1, m_width, mscale)) / 4.0f;
+    
+    Dzz = pop_response(t, c, r, t_width, 1) - 
+          pop_response(b, c, r, b_width, bscale) - 2.0f * v;
+    
+    Dxz = (pop_response(t, c+1, r, t_width, 1) -
+           pop_response(t, c-1, r, t_width, 1) -
+           pop_response(b, c+1, r, b_width, bscale) +
+           pop_response(b, c-1, r, b_width, bscale)) / 4.0f;
+    
+    Dyz = (pop_response(t, c, r+1, t_width, 1) -
+           pop_response(t, c, r-1, t_width, 1) -
+           pop_response(b, c, r+1, b_width, bscale) +
+           pop_response(b, c, r-1, b_width, bscale)) / 4.0f;
+    
+    float det = Dxx * (Dyy*Dzz - Dyz*Dyz) -
+                Dxy * (Dxy*Dzz - Dyz*Dxz) +
+                Dxz * (Dxy*Dyz - Dyy*Dxz);
+
+    float invdet = 1.0f / det;
+    
+    float invDxx =  (Dyy*Dzz-Dyz*Dyz) * invdet;
+    float invDxy = -(Dxy*Dzz-Dyz*Dxz) * invdet;
+    float invDxz =  (Dxy*Dyz-Dyy*Dxz) * invdet;
+    float invDyx = -(Dxy*Dzz-Dxz*Dyz) * invdet;
+    float invDyy =  (Dxx*Dzz-Dxz*Dxz) * invdet;
+    float invDyz = -(Dxx*Dyz-Dxy*Dxz) * invdet;
+    float invDzx =  (Dxy*Dyz-Dxz*Dyy) * invdet;
+    float invDzy = -(Dxx*Dyz-Dxz*Dxy) * invdet;
+    float invDzz =  (Dxx*Dyy-Dxy*Dxy) * invdet;
+    
+    // derivative * hessian
+    
+    float xi = 0.0f, xr = 0.0f, xc = 0.0f;
+    
+    xc -= invDxx * Dx;
+    xc -= invDxy * Dy;
+    xc -= invDxz * Dz;
+    
+    xr -= invDyx * Dx;
+    xr -= invDyy * Dy;
+    xr -= invDyz * Dz;
+    
+    xc -= invDzx * Dx;
+    xc -= invDzy * Dy;
+    xc -= invDzz * Dz;
+    
+    // extremum??
+    if(fabs(xi) < 0.5f && fabs(xr) < 0.5f && fabs(xc) < 0.5f) {
+        
+        int fstep = m_filter - b_filter;
+        
+        (*pos).x = (float)((c + xc) * fstep);
+        (*pos).y = (float)((c + xr) * fstep);
+        *det_scale = (float)(0.1333f) * (m_filter + (xi * fstep));
+        
+        int s = m_width / t_width;
+        *laplacian = pop_laplacian(mlaplacian, c * s, r * s, m_width);
+        
+        return true;
+    }
+    
+    return false;
+        
+}
+
+bool is_extremum(
+                 int r,
+                 int c,
+                 read_only image2d_t t,
+                 int t_width,
+                 int t_height,
+                 int t_step,
+                 int t_filter,
+                 read_only image2d_t m,
+                 int m_width,
+                 int m_height,
+                 read_only image2d_t b,
+                 int b_width,
+                 int b_height,
+                 float tresh
+                 )
+{
+    int border = (t_filter + 1) / (2 * t_step);
+    
+    if(r <= border || r >= t_height - border || c <= border || c >= t_width - border) {
+        return false;
+    }
+ 
+    int mscale = m_width / t_width;
+    
+    float candidate = pop_response(m, c, r, m_width, mscale);
+    if(candidate < tresh) {
+        return false;
+    }
+    
+    // If any response in 3x3x3 is greater candidate not maximum
+    float localMax =          getResponse(t, c-1, r-1, t_width, 1);
+    localMax = fmax(localMax, getResponse(t, c,   r-1, t_width, 1));
+    localMax = fmax(localMax, getResponse(t, c+1, r-1, t_width, 1));
+    localMax = fmax(localMax, getResponse(t, c-1, r,   t_width, 1));
+    localMax = fmax(localMax, getResponse(t, c,   r,   t_width, 1));
+    localMax = fmax(localMax, getResponse(t, c+1, r,   t_width, 1));
+    localMax = fmax(localMax, getResponse(t, c-1, r+1, t_width, 1));
+    localMax = fmax(localMax, getResponse(t, c,   r+1, t_width, 1));
+    localMax = fmax(localMax, getResponse(t, c+1, r+1, t_width, 1));
+    
+    int bScale = b_width/t_width;
+    
+    localMax = fmax(localMax, getResponse(b, c-1, r-1, b_width, bScale));
+    localMax = fmax(localMax, getResponse(b, c,   r-1, b_width, bScale));
+    localMax = fmax(localMax, getResponse(b, c+1, r-1, b_width, bScale));
+    localMax = fmax(localMax, getResponse(b, c-1, r,   b_width, bScale));
+    localMax = fmax(localMax, getResponse(b, c,   r,   b_width, bScale));
+    localMax = fmax(localMax, getResponse(b, c+1, r,   b_width, bScale));
+    localMax = fmax(localMax, getResponse(b, c-1, r+1, b_width, bScale));
+    localMax = fmax(localMax, getResponse(b, c,   r+1, b_width, bScale));
+    localMax = fmax(localMax, getResponse(b, c+1, r+1, b_width, bScale));
+    
+    //int mScale = m_width/t_width;
+    
+    localMax = fmax(localMax, getResponse(m, c-1, r-1, m_width, mScale));
+    localMax = fmax(localMax, getResponse(m, c,   r-1, m_width, mScale));
+    localMax = fmax(localMax, getResponse(m, c+1, r-1, m_width, mScale));
+    localMax = fmax(localMax, getResponse(m, c-1, r,   m_width, mScale));
+    // This is the candidate pixel
+    localMax = fmax(localMax, getResponse(m, c+1, r,   m_width, mScale));
+    localMax = fmax(localMax, getResponse(m, c-1, r+1, m_width, mScale));
+    localMax = fmax(localMax, getResponse(m, c,   r+1, m_width, mScale));
+    localMax = fmax(localMax, getResponse(m, c+1, r+1, m_width, mScale));
+    
+    // If localMax > candidate, candidate is not the local maxima
+    if(localMax > candidate) {
+        return false;
+    }
+    
+    return true;   
+    
+}
+
+__kernel void suppress_non_max(                               
+               read_only image2d_t tResponse,
+                               int t_width,
+                               int t_height,
+                               int t_filter,
+                               int t_step,
+               read_only image2d_t mResponse,                
+               read_only image2d_t mLaplacian,
+                               int m_width,
+                               int m_height,
+                               int m_filter,
+               read_only image2d_t bResponse,           
+                               int b_width;
+                               int b_height,
+                               int b_filter,
+                      __global int* pts_cnt,
+                   __global float2* pix_pos,
+                    __global float* scale,
+                      __global int* laplacian,
+                               int max_pts,
+                             float tresh                               
+                               )
+{
+    int r = get_global_id(0);
+    int c = get_global_id(1);
+    
+    float2 pixpos;
+    float s;
+    int lap;
+    
+    
+    if(is_extremum(r, c, tResponse, t_width, t_height, t_step, t_filter, mResponse, m_width, m_height, bResponse, b_width, b_height, tresh)) {
+        
+        if(interpolate_extremum(r, c, pts_cnt, &pixpos, &s, &lap, tResponse, t_width, t_height, t_step, mResponse, mLaplacian, m_width, m_height, m_filter, bResponse, b_width, b_height, b_filter)) {
+            
+            int indx = atom_add(&pts_cnt[0],1);
+            if(indx < max_pts) {
+                pix_pos[indx] = pix_pos;
+                scale[indx] = s;
+                laplacian[indx] = lap;
+            }
+            
+        }
+        
+    }
+}
+                               
+                               
+                          
+                          
+                          
+
+
+
+

dviid/imgproc.cl

@@ -0,0 +1,148 @@
+/*
+ ~ copyright (c) 2011 dviid
+ ~ contact: dviid@labs.ciid.dk 
+ 
+ + redistribution and use in source and binary forms, with or without
+ + modification, are permitted provided that the following conditions
+ + are met:
+ +  > redistributions of source code must retain the above copyright
+ +    notice, this list of conditions and the following disclaimer.
+ +  > redistributions in binary form must reproduce the above copyright
+ +    notice, this list of conditions and the following disclaimer in
+ +    the documentation and/or other materials provided with the
+ +    distribution.
+ 
+ + THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ + "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ + LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+ + FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+ + COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+ + INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+ + BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
+ + OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
+ + AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ + OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
+ + OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ + SUCH DAMAGE.
+ 
+ ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+ */
+
+const sampler_t smp = CLK_ADDRESS_CLAMP_TO_EDGE | CLK_FILTER_NEAREST;
+
+__kernel void sobel(read_only image2d_t src, write_only image2d_t dst)
+{
+    int2 coords = (int2) (get_global_id(0), get_global_id(1));
+    int2 dx = (int2)(1,0);
+    int2 dy = (int2)(0,1);
+    float Gx, Gy, G, theta, p;
+    
+    if(coords.x > get_image_width(dst) || coords.y > get_image_height(dst))
+        return;
+    
+    p = read_imagef(src, smp, coords - dx + dy).s0;
+    Gx = p;
+    Gy = p;
+    
+    p = read_imagef(src, smp, coords + dy).s0;
+    Gy += 2 * p;
+
+    p = read_imagef(src, smp, coords + dx + dy).s0;
+    Gx -= p;
+    Gy += p;
+    
+    p = read_imagef(src, smp, coords - dx).s0;
+    Gx += 2 * p;
+    
+    p = read_imagef(src, smp, coords + dx).s0;
+    Gx -= 2 * p;
+
+    p = read_imagef(src, smp, coords - dx - dy).s0;
+    Gx += p;
+    Gy -= p;
+    
+    p = read_imagef(src, smp, coords - dy).s0;
+    Gy -= 2 * p;
+    
+    p = read_imagef(src, smp, coords + dx - dy).s0;
+    Gx -= p;
+    Gy -= p;
+    
+    G = sqrt(Gx * Gx + Gy * Gy);
+    theta = atan(Gx / Gy);
+    
+    write_imagef(dst, coords, G);                
+    
+}
+
+__kernel void hgauss(read_only image2d_t src, write_only image2d_t dst, 
+                     global read_only float* weights, global float* offsets, const int nbr_weights)
+{
+    int2    coords = (int2) (get_global_id(0), get_global_id(1));
+    float2  src_coords = (float2) (get_global_id(0), get_global_id(1));
+    float4  pix = (float4)(0,0,0,0);
+
+    int i;
+    for(i = 0; i < nbr_weights; i++) {
+        pix += read_imagef(src, smp, src_coords + (float2) (offsets[i], 0.0f)) * weights[i];
+    }
+    
+    write_imagef(dst, coords, clamp(pix, 0.0f, 1.0f));
+}
+
+__kernel void vgauss(read_only image2d_t src, write_only image2d_t dst, 
+                     global read_only float* weights, global float* offsets, const int nbr_weights)
+{
+    int2    coords = (int2) (get_global_id(0), get_global_id(1));
+    float2  src_coords = (float2) (get_global_id(0), get_global_id(1));
+    float4  pix = (float4)(0,0,0,0);
+    
+    int i;
+    for(i = 0; i < nbr_weights; i++) {
+        pix += read_imagef(src, smp, src_coords + (float2) (0.0f, offsets[i])) * weights[i];
+    }
+    
+    write_imagef(dst, coords, clamp(pix, 0.0f, 1.0f));
+}
+
+
+
+__kernel void grey(read_only image2d_t src, write_only image2d_t dst)
+{
+    int2 coords = (int2) (get_global_id(0), get_global_id(1));
+    float4 color = read_imagef(src, smp, coords);
+	float luminance = 0.3f * color.x + 0.59 * color.y + 0.11 * color.z;
+	color = (float4)(luminance, luminance, luminance, 1.0f);
+	write_imagef(dst, coords, color);
+}
+
+__kernel void brightness(read_only image2d_t src, write_only image2d_t dst)
+{
+    float max = 0;
+    int2 coords = (int2) (get_global_id(0), get_global_id(1));
+    float4 color = read_imagef(src, smp, coords);
+
+    max = color.x;
+    if(color.y > max) { max = color.y; }
+    if(color.z > max) { max = color.z; }    
+    
+	write_imagef(dst, coords, max);
+}
+
+__kernel void lightness(read_only image2d_t src, write_only image2d_t dst)
+{
+    float l = 0;
+    int2 coords = (int2) (get_global_id(0), get_global_id(1));
+    float4 color = read_imagef(src, smp, coords);
+    
+    l = (color.x + color.y + color.z) / 3.0f;
+    
+	write_imagef(dst, coords, l);
+}
+
+
+
+__kernel void hist()
+{
+    
+}

dviid/intimg.cl

@@ -0,0 +1,130 @@
+/*
+ ~ copyright (c) 2011 dviid
+ ~ contact: dviid@labs.ciid.dk 
+ 
+ + redistribution and use in source and binary forms, with or without
+ + modification, are permitted provided that the following conditions
+ + are met:
+ +  > redistributions of source code must retain the above copyright
+ +    notice, this list of conditions and the following disclaimer.
+ +  > redistributions in binary form must reproduce the above copyright
+ +    notice, this list of conditions and the following disclaimer in
+ +    the documentation and/or other materials provided with the
+ +    distribution.
+ 
+ + THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ + "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ + LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+ + FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+ + COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+ + INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+ + BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
+ + OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
+ + AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ + OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
+ + OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ + SUCH DAMAGE.
+ 
+ ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+ */
+
+#define WORK_G_SIZE         64
+#define HALF_WORK_G_SIZE    (WORK_G_SIZE / 2)
+
+const sampler_t smp = CLK_NORMALIZED_COORDS_FALSE | CLK_ADDRESS_CLAMP_TO_EDGE | CLK_FILTER_NEAREST;
+
+__kernel void scan(read_only image2d_t src, write_only image2d_t dst, int rows, int cols)
+{
+    __local float data0[WORK_G_SIZE + HALF_WORK_G_SIZE];
+    __local float data1[WORK_G_SIZE + HALF_WORK_G_SIZE];
+    
+    int2 coords = (int2) (get_global_id(0), get_global_id(1));
+    int X = coords.x;
+    int Y = coords.x;
+    
+    if(coords.x < HALF_WORK_G_SIZE) {
+        data0[coords.x] = 0.0f;
+        data1[coords.x] = 0.0f;
+    }
+    
+    X += HALF_WORK_G_SIZE;    
+    float max_val = 0.0f;    
+    
+    int it = cols / WORK_G_SIZE;    
+    if(cols % WORK_G_SIZE != 0) {
+        it++;
+    }
+    
+    for(int i = 0; i < it; i++) {
+        
+        int col_offset = i * WORK_G_SIZE + coords.x;
+        
+        data0[X] = read_imagef(src, smp, (int2)(col_offset, Y)).x;        
+        barrier(CLK_LOCAL_MEM_FENCE);
+        
+        // 1
+        data1[X] = data0[X] + data0[X-1];
+        barrier(CLK_LOCAL_MEM_FENCE);
+        
+        // 2
+        data0[X] = data1[X] + data1[X-2];
+        barrier(CLK_LOCAL_MEM_FENCE);
+        
+        // 4
+        data1[X] = data0[X] + data0[X-4];
+        barrier(CLK_LOCAL_MEM_FENCE);
+        
+        // 8
+        data0[X] = data1[X] + data1[X-8];
+        barrier(CLK_LOCAL_MEM_FENCE);
+        
+        // 16
+        data1[X] = data0[X] + data0[X-16];
+        barrier(CLK_LOCAL_MEM_FENCE);
+        
+        // 32
+        data0[X] = data1[X] + data1[X-32];
+        barrier(CLK_LOCAL_MEM_FENCE);
+        
+        if(col_offset < cols) {
+            write_imagef(dst, (int2)(col_offset, Y), (float4)(data0[X] + max_val, 0.0f, 0.0f, 0.0f));
+        }
+        
+        max_val += data0[WORK_G_SIZE + HALF_WORK_G_SIZE - 1];
+    }
+    
+}
+
+__kernel void transpose(read_only image2d_t src, write_only image2d_t dst, int rows, int cols)
+{
+    
+    __local float buff[256];
+    
+    int2 coords = (int2) (get_global_id(0), get_global_id(1));
+    
+    int inX = coords.x;
+    int inY = coords.y;
+    
+    int lX = coords.x;
+    int lY = coords.y;
+    
+    int ginX = coords.x * 16 + lX;
+    int ginY = coords.y * 16 + lY;
+    
+    buff[lY * 16 + lX] = read_imagef(src, smp, (int2)(ginX, ginY)).x;
+    barrier(CLK_LOCAL_MEM_FENCE);
+    
+    int outRows = rows;
+    int outCols = cols;
+    
+    int outX = inX;
+    int outY = inY;
+    
+    int goutX = coords.x * 16 + lX;
+    int goutY = coords.y * 16 + lY;
+    
+    if(goutX >= 0 && goutX < outCols && goutY >=0 && goutY < outRows) {
+        write_imagef(dst, (int2)(goutX, goutY), (float4)(buff[lX * 16 + lY], 0.0f, 0.0f, 0.0f));
+    }
+}
+

dviid/rfi.frag.glsl

@@ -0,0 +1,18 @@
+#version 120
+
+uniform int           algo;
+uniform sampler2DRect tex0;
+
+void main() {
+
+    if(algo == 4) {
+        vec4 color = texture2DRect(tex0, gl_TexCoord[0].st);
+        float luminance = 0.3f * color.x + 0.59 * color.y + 0.11 * color.z;
+        //gl_FragColor = vec4(luminance, luminance, luminance, 1.0f);
+        gl_FragColor = vec4(1.0f, 1.0f, 1.0f, 0.5f);   
+        return;     
+    }
+
+    gl_FragColor = texture2DRect(tex0, gl_TexCoord[0].st);
+
+}

dviid/rfi.geom.glsl

@@ -0,0 +1,127 @@
+#version 120
+#extension GL_EXT_geometry_shader4 : enable
+
+#define ALGO_1  1
+#define ALGO_2  2
+#define ALGO_3  3
+#define ALGO_4  4
+
+uniform int             algo;
+uniform float           scale;
+uniform sampler2DRect   tex0;
+
+float max_color(vec3 rgb)
+{
+    float max = rgb.r;
+    if(rgb.g > max) { max = rgb.g; }
+    if(rgb.b > max) { max = rgb.b; }  
+    return max;
+} 
+
+float min_color(vec3 rgb)
+{
+    float min = rgb.r;
+    if(rgb.g < min) { min = rgb.g; }
+    if(rgb.b < min) { min = rgb.b; }  
+    return min;
+} 
+
+void hue(in vec4 color, out float h)
+{
+	float max = max_color(color.rgb);	
+	float min = min_color(color.rgb);
+    if(max == min) { h = 0.f; }
+    
+	float hueSixth;
+	if(color.r == max) {
+		hueSixth = (color.g - color.b) / (max - min);
+		if(hueSixth < 0.f)
+			hueSixth += 6.f;
+	} else if (color.g == max) {
+		hueSixth = 2.f + (color.b - color.r) / (max - min);
+	} else {
+		hueSixth = 4.f + (color.r - color.g) / (max - min);
+	}
+    
+	h = 255.f * hueSixth / 6.f;    
+}
+
+void saturation(in vec4 color, out float s)
+{
+	float max = max_color(color.rgb);	
+	float min = min_color(color.rgb);
+    if(max == min) { s = 0.f; }
+    
+    s = 255.f * (max - min) / max;
+}
+
+void brightness(in vec4 color, out float b)
+{
+    b = max_color(color.rgb);
+}
+
+void toHSB(in vec3 rgb, out vec3 hsb) 
+{
+	float max = max_color(rgb);	
+	float min = min_color(rgb);
+	
+	if(max == min) {
+		hsb.x = 0.f;
+		hsb.y = 0.f;
+		hsb.z = 255.f * max;
+		return;
+	}
+	
+	float hueSixth;
+	if(rgb.r == max) {
+		hueSixth = (rgb.g - rgb.b) / (max - min);
+		if(hueSixth < 0.f)
+			hueSixth += 6.f;
+	} else if (rgb.g == max) {
+		hueSixth = 2.f + (rgb.b - rgb.r) / (max - min);
+	} else {
+		hueSixth = 4.f + (rgb.r - rgb.g) / (max - min);
+	}
+	hsb.x = 255.f * hueSixth / 6.f;
+	hsb.y = 255.f * (max - min) / max;
+	hsb.z = max;
+}
+
+void main()
+{
+
+    if(algo == ALGO_4 && mod(gl_PositionIn[0].y, 2.f) != 0) return;
+
+	for (int i = 0; i < gl_VerticesIn; i++)
+	{
+ 
+		gl_Position = gl_PositionIn[i];
+        
+        vec4 color0 = texture2DRect(tex0, gl_TexCoordIn[i][0].st);
+        
+        float depth = 0.f;
+        
+        if(algo == ALGO_1) {
+            brightness(color0, depth);
+        } 
+        else if(algo == ALGO_2) {
+            hue(color0, depth);
+        }
+        else if(algo == ALGO_3) {
+            saturation(color0, depth);
+        }
+        else if(algo == ALGO_4) {
+            brightness(color0, depth);
+        }
+        else {
+            brightness(color0, depth);
+        }                
+                
+        gl_Position = gl_ModelViewProjectionMatrix * vec4(gl_Position.x, gl_Position.y, depth * scale, 1.0);
+        gl_TexCoord[0] = gl_TexCoordIn[i][0];
+                
+		EmitVertex();        
+	}    
+    
+    
+}

dviid/rfi.vert.glsl

@@ -0,0 +1,11 @@
+#version 120
+
+void main()
+{
+
+	gl_FrontColor =  gl_Color;
+	gl_TexCoord[0] = gl_MultiTexCoord0;
+	gl_Position = gl_Vertex;
+    
+    
+}

example/RefractiveIndex.cpp

@@ -15,6 +15,11 @@
 
 #include "ofxXmlSettings.h"
 
+#include "ofxArcBall.h"
+
+#include <stdio.h>
+#include <stdlib.h>
+
 #define CAMERA_ID           0
 #define CAMERA_ACQU_WIDTH   640
 #define CAMERA_ACQU_HEIGHT  480
@@ -27,6 +32,22 @@
 #define ISTATE_TRANSITION   0xCCCC
 #define ISTATE_END          0xDDDD
 
+static const int subdiv_pixels = 4;
+
+static const int VID_W = 640, VID_H = 480;
+static const int VERTICES_X = VID_W / subdiv_pixels, VERTICES_Y = VID_W / subdiv_pixels;
+static const int TRI_W = 1000;
+
+int draw_style = FACE;
+
+#define ALGO_1  1
+#define ALGO_2  2
+#define ALGO_3  3
+#define ALGO_4  4
+
+int             algo = ALGO_2;
+float           scale = 1.f;
+
 
 int _state = ISTATE_UNDEF;
 
@@ -40,8 +61,64 @@ string           RefractiveIndex::_location;
 
 ofxXmlSettings   RefractiveIndex::XML;
 
+ofShader        RefractiveIndex::_shader;
+ofVboMesh       RefractiveIndex::_mesh_vbo;
+
+//ofxArcBall      RefractiveIndex::cam;
+
+string          msg;
+
+void RefractiveIndex::setup_shader_vbo()
+{
+    
+    int vertices_per_frame = XML.getValue("config:algorithms:vertices_per_frame", TRI_W);
+    int pixel_per_vertex = XML.getValue("config:algorithms:pixel_per_vertex", subdiv_pixels);
+    
+    int vertices_X = _vid_w / pixel_per_vertex, vertices_Y = _vid_h / pixel_per_vertex;
+    
+    // VBO        
+    for(int i = 0; i < vertices_X; i++){
+        for(int j = 0; j < vertices_Y; j++) {
+            _verts.push_back(ofVec3f((i / (float)vertices_X) * vertices_per_frame, (j / (float) vertices_Y) * vertices_per_frame, 0.0f));
+            _tex.push_back(ofVec2f(i / (float)vertices_X * _vid_w, j / (float) vertices_Y * _vid_h));
+			if( ( i + 1 < vertices_X ) && ( j + 1 < vertices_Y ) ) {                
+                //triangle #1
+                _ind.push_back( (i+0) * vertices_Y + (j+0) );
+                _ind.push_back( (i+1) * vertices_Y + (j+0) );
+                _ind.push_back( (i+1) * vertices_Y + (j+1) );
+                
+                //triangle #2
+                _ind.push_back( (i+1) * vertices_Y + (j+1) );
+                _ind.push_back( (i+0) * vertices_Y + (j+1) );
+                _ind.push_back( (i+0) * vertices_Y + (j+0) );
+			}
+        }
+    }
+    
+    //ofEnableNormalizedTexCoords();
+    
+    _mesh_vbo.addVertices(_verts);
+    _mesh_vbo.addTexCoords(_tex);
+    _mesh_vbo.addIndices(_ind);
+    
+    _mesh_vbo.setMode(OF_PRIMITIVE_TRIANGLES);
+        
+    // geometry shader
+    
+	_shader.setGeometryInputType(GL_TRIANGLES);
+	_shader.setGeometryOutputType(GL_TRIANGLES);
+	_shader.setGeometryOutputCount(3);
+    _shader.load("dviid/rfi.vert.glsl", "dviid/rfi.frag.glsl", "dviid/rfi.geom.glsl"); 	
+	printf("Maximum number of output vertices support is: %i\n", _shader.getGeometryMaxOutputCount());    
+}
+
+
 void RefractiveIndex::setup()
 {
+    ofSetLogLevel(OF_LOG_VERBOSE);
+    
+    ofHideCursor();
+    
     bool save_config = false;
     
     cout << "Loading configuration..." << endl;
@@ -97,42 +174,32 @@ void RefractiveIndex::setup()
 
     _analysisAdapator = NULL;
 
-    //getting a warning from the OFlog that the pixels aren't allocated
+    _pixels.allocate(_vid_w, _vid_h, OF_IMAGE_COLOR_ALPHA); 
-    //void ofPixels::allocate(int w, int h, ofImageType type)    
+    
-    _pixels.allocate(_vid_w, _vid_h, OF_IMAGE_COLOR); 
+    
+    setup_shader_vbo();
     
     
     //TODO:  whichever one of these is first - it always runs twice ?    
     
-    _analysisVector.push_back(new ShadowScapesAnalysis(V)); 
+    _analysisVector.push_back(new ShadowScapesAnalysis(V)); //1
-    _analysisVector.push_back(new ShadowScapesAnalysis(H));
+    _analysisVector.push_back(new ShadowScapesAnalysis(H)); //2
-    _analysisVector.push_back(new ShadowScapesAnalysis(D));
+    _analysisVector.push_back(new ShadowScapesAnalysis(D)); //3
-	    
+    _analysisVector.push_back(new RelaxRateAnalysis());     //4
-    _analysisVector.push_back(new RelaxRateAnalysis());
+    _analysisVector.push_back(new IResponseAnalysis());     //5
-    
+    _analysisVector.push_back(new ShapeFromShadingAnalysis()); //6   
-	
+    _analysisVector.push_back(new StrobeAnalysis());        //7
-    _analysisVector.push_back(new IResponseAnalysis());
+    _analysisVector.push_back(new CamNoiseAnalysis());      //8
-    
+    _analysisVector.push_back(new ColorSingleAnalysis());   //9
-    _analysisVector.push_back(new ShapeFromShadingAnalysis());
+    _analysisVector.push_back(new ColorMultiAnalysis());    //10
-    
+    _analysisVector.push_back(new DiffNoiseAnalysis());	    //11
-    _analysisVector.push_back(new StrobeAnalysis());
-    
-    _analysisVector.push_back(new CamNoiseAnalysis());
-    
-    _analysisVector.push_back(new ColorSingleAnalysis());
-    
-    _analysisVector.push_back(new ColorMultiAnalysis());
-    
-    _analysisVector.push_back(new DiffNoiseAnalysis());	
-    
-
-    //_currentAnalysisIndx = 0;
-    //_currentAnalysis = _analysisVector.at(_currentAnalysisIndx++); 
-    //_state = ISTATE_START;
     
     _currentAnalysis = NULL;
     _state = ISTATE_UNDEF;
     
+    // disbale <ESC> ?
+    //ofSetEscapeQuitsApp(false);
+    
 }
 
 void RefractiveIndex::analysis_cb(string & analysis)
@@ -173,7 +240,6 @@ void RefractiveIndex::state_analysis()
                 _currentAnalysisIndx = 0;
                 _currentAnalysis = _analysisVector.at(_currentAnalysisIndx++);
                 _state = ISTATE_START;                
-                //_state = ISTATE_END;
             } else {
                 _currentAnalysis = _analysisVector.at(_currentAnalysisIndx++);
                 _state = ISTATE_START;
@@ -205,9 +271,6 @@ void RefractiveIndex::update()
 
 void RefractiveIndex::draw()
 {    
-    // refractive mauve - this doesn't work... looks weird in various places.
-    //ofBackground(113, 110, 136);
-    
     // black
     ofBackground(0, 0, 0);
            
@@ -246,15 +309,10 @@ void RefractiveIndex::stop_camera()
 
 void RefractiveIndex::keyPressed  (int key)
 {
+    
     if( key =='f')
         ofToggleFullscreen();
     
-    /*  TODO:  complete the below... would be good to trigger the Analysis from keypresses if needed... */
-    // currently this doesn't work... the save_cb's in the individual 
-    // tried to add a  stop_analysis(); call but it blocks the whole programme
-    
-    // i.e.: ask david how to shut off the prior Analysis if it's not finished running from here? 
-    
     if(key == 'x')
     {
         if(_currentAnalysis)
@@ -362,48 +420,6 @@ void RefractiveIndex::keyPressed  (int key)
             _state = ISTATE_TRANSITION;            
     }    
     
-    /*
-     TO DO:  add a file dialog so we can save images to another hard drive...
-     e.g.: http://dev.openframeworks.cc/pipermail/of-dev-openframeworks.cc/2011-April/003125.html
-     
->> 		case 's':
->> 			doSave ^= true;
->> 			doLoad = false;
->> 			if(doSave) {
->> 				ofFileDialogResult r = ofSystemLoadDialog("Select path to save to", true);
->> 				if(r.bSuccess) {
->> 					saveCounter = 0;
->> 					savePath = r.getPath();
->> 					ofDirectory::createDirectory(savePath + "/color/");
->> 					ofDirectory::createDirectory(savePath + "/depth/");
->> 					printf("SAVE %s %s\n", r.getPath().c_str(), r.getName().c_str());
->> 				} else {
->> 					doSave = false;
->> 				}
->> 				
->> 			}
->> 			break;
->> 			
->> 		case 'l':
->> 			doLoad ^= true;
->> 			doSave = false;
->> 			if(doLoad) {
->> 				ofFileDialogResult r = ofSystemLoadDialog("Select path to load from", true);
->> 				if(r.bSuccess) {
->> 					loadCounter = 0;
->> 					loadPath = r.getPath();
->> 					ofDirectory dir;
->> 					loadMaxFiles = MAX(dir.listDir(loadPath + "/color"), dir.listDir(loadPath + "/depth"));
->> 					printf("LOAD %i %s %s\n", loadMaxFiles, r.getPath().c_str(), r.getName().c_str());
->> 				} else {
->> 					doLoad = false;
->> 				}
->> 				
->> 			}
->> 			break;
-    */
-    
-    
 }
 
 void RefractiveIndex::exit()

example/RefractiveIndex.h

@@ -11,9 +11,15 @@
 #include "ofxOpenCv.h"
 #include "ofxXmlSettings.h"
 
+#include "ofxArcBall.h"
+
 #define MODE_DRAWING        0xEEFF
 #define MODE_ANALYSING      0xFFEE
 
+#define VERTS   1
+#define WIRE    2
+#define FACE    3
+
 class RefractiveIndex : public ofBaseApp
 {
 public:
@@ -32,6 +38,8 @@ public:
     void stop_analysis();
     void state_analysis();
     
+    void setup_shader_vbo();
+    
     // ofx
     void keyPressed  (int key);
     void keyReleased(int key){;}
@@ -69,4 +77,16 @@ public:
     static string           _location;
     static ofxXmlSettings   XML;  // made this static so we can access RUN_NUM in the analyses 
     
+    
+    static ofVboMesh       _mesh_vbo;
+    
+    vector<ofVec3f> _verts;
+    vector<ofVec2f> _tex;
+    vector<unsigned int> _ind;
+    
+    static ofxArcBall cam;
+    
+    static ofShader        _shader;
+    
+    
 };

src/AbstractAnalysis.cpp

@@ -20,6 +20,16 @@ void AbstractAnalysis::setup(int camWidth, int camHeight) {
         _whole_file_path_synthesis = r.filePath + "/darwings";        
     }
     
+    // viewport
+    
+    tx = RefractiveIndex::XML.getValue("config:viewport:tx", 200.0);
+    ty = RefractiveIndex::XML.getValue("config:viewport:ty", 50.0);
+    tz = RefractiveIndex::XML.getValue("config:viewport:tz", -500.0);
+    
+    rx = RefractiveIndex::XML.getValue("config:viewport:rx", 0.0);
+    ry = RefractiveIndex::XML.getValue("config:viewport:ry", 0.0);
+    rz = RefractiveIndex::XML.getValue("config:viewport:rz", 0.0);
+    
 }
 
 // this is the main threaded loop for a given analysis
@@ -44,8 +54,9 @@ void AbstractAnalysis::do_synthesize() {
                 if(_state == STATE_STOP) goto exit;
                 _state = STATE_DISPLAY_RESULTS;
                 displayresults();
-                cleanup();
             }       
+            
+            break;
         }
             
         case MODE_DRAWING:
@@ -61,12 +72,14 @@ void AbstractAnalysis::do_synthesize() {
             if(_state == STATE_STOP) goto exit;
             _state = STATE_DISPLAY_RESULTS;
             displayresults();   
-            cleanup();            
+            
+            break;
         }
     }
     
 exit:    
     cleanup();
+    ofxFileHelper::deleteFolder(_whole_file_path_analysis);
     ofNotifyEvent(_synthesize_cb, _name);    
     
 }
@@ -118,6 +131,7 @@ void AbstractAnalysis::create_dir_allocate_images()
         
     }
     
+    
     _whole_file_path_synthesis = SYNTHESIS_PATH + RefractiveIndex::_location + "/" + _name + "/"+replaceTime;
     
     if(!fileHelperSynthesis.doesDirectoryExist(_whole_file_path_synthesis)){
@@ -135,6 +149,7 @@ void AbstractAnalysis::create_dir_allocate_images()
         fileHelperSynthesis.makeDirectory(SYNTHESIS_PATH+RefractiveIndex::_location+"/"+_name+"/"+replaceTime);
         
     }
+    
     //////////////////////////////END DIRECTORY CREATION //////////////////////////////////////////////////  
     
     
@@ -177,9 +192,6 @@ void AbstractAnalysis::read_dir_create_list(string folder_path)
         for(int i = 0; i < list.size(); i++) {
             string filepath = folder_path + "/" + list[i]; 
             _saved_filenames_analysis.push_back(filepath);
-                        
-            cout << list[i] << endl; 
-            
         }                
     }
 }
@@ -192,6 +204,7 @@ void AbstractAnalysis::saveImageAnalysis(string filename)
     if (RefractiveIndex::_vidGrabber.isFrameNew())
     {
         RefractiveIndex::_pixels = RefractiveIndex::_vidGrabber.getPixelsRef(); //get ofPixels from the camera
+        
     } else {
         return;
     }

src/AbstractAnalysis.h

@@ -81,5 +81,9 @@ protected:
     int             NUM_RUN;
     int             NUM_SAVE_PER_RUN;  
     
+    //viewport
+    
+    float tx, ty, tz, rx, ry, rz;    
+    
     friend class AnalysisAdaptor;
 };

src/CamNoiseAnalysis.cpp

@@ -13,6 +13,13 @@ using Poco::Thread;
 #define NUMBER_RUNS     1
 #define ACQUIRE_TIME    20
 
+const int algo_default = 1;
+const int scale_default = 500;
+const int draw_style_default = 3;
+const int line_width_default = 0.5f;
+const float point_size_default = 0.5f;
+
+
 void CamNoiseAnalysis::setup(int camWidth, int camHeight)
 {
     AbstractAnalysis::setup(camWidth, camHeight);
@@ -47,52 +54,25 @@ void CamNoiseAnalysis::setup(int camWidth, int camHeight)
     _show_image = false;
     _image_shown = false;
 
+    
     image1.clear();
     image2.clear();
-    image3.clear();
-    image4.clear();
-    image5.clear();
     
     //  images use for drawing the synthesized files to the screen ///
     image1.setUseTexture(false);  // the non texture image that is needed to first load the image
     image2.setUseTexture(true);   // the image that needs to get written to the screen which takes the content of image1
     
-    //  images used for re-loading and saving out the synthesized files ///
-    image3.setUseTexture(false);
-    image4.setUseTexture(false);
-    image5.setUseTexture(false);
-
     image1.allocate(RefractiveIndex::_vid_w,RefractiveIndex::_vid_h,  OF_IMAGE_COLOR);
     image2.allocate(RefractiveIndex::_vid_w,RefractiveIndex::_vid_h,  OF_IMAGE_COLOR);
-    image3.allocate(RefractiveIndex::_vid_w,RefractiveIndex::_vid_h,  OF_IMAGE_COLOR);
-    image4.allocate(RefractiveIndex::_vid_w,RefractiveIndex::_vid_h,  OF_IMAGE_COLOR);
-    image5.allocate(RefractiveIndex::_vid_w,RefractiveIndex::_vid_h,  OF_IMAGE_COLOR);
     
-    //cout << "RefractiveIndex::_vid_w " << RefractiveIndex::_vid_w << endl;
-    //cout << "RefractiveIndex::_vid_h " << RefractiveIndex::_vid_h << endl;
     
-    // clear() apparently fixes the "OF_WARNING: in allocate, reallocating a ofxCvImage"
+    ////---------
-    // that we're getting in OSX/Windows and is maybe crashing Windows
-    // http://forum.openframeworks.cc/index.php?topic=1867.0
-    cvColorImage1.clear();
-	cvGrayImage1.clear();
-    cvGrayDiff1.clear();
     
-    cvColorImage2.clear();
+    algo = RefractiveIndex::XML.getValue("config:algorithms:camnoise:algo", algo_default);
-	cvGrayImage2.clear();
+    scale = RefractiveIndex::XML.getValue("config:algorithms:camnoise:scale", scale_default);
-    cvGrayDiff2.clear();
+    draw_style = RefractiveIndex::XML.getValue("config:algorithms:camnoise:draw_style", draw_style_default);
-
+    line_width = RefractiveIndex::XML.getValue("config:algorithms:camnoise:line_width", line_width_default);        
-    cvConvertorImage.clear();
+    point_size = RefractiveIndex::XML.getValue("config:algorithms:camnoise:point_size", point_size_default);
-
-    cvColorImage1.allocate(RefractiveIndex::_vid_w,RefractiveIndex::_vid_h);
-	cvGrayImage1.allocate(RefractiveIndex::_vid_w,RefractiveIndex::_vid_h);
-    cvGrayDiff1.allocate(RefractiveIndex::_vid_w,RefractiveIndex::_vid_h);
-
-    cvColorImage2.allocate(RefractiveIndex::_vid_w,RefractiveIndex::_vid_h);
-	cvGrayImage2.allocate(RefractiveIndex::_vid_w,RefractiveIndex::_vid_h);
-    cvGrayDiff2.allocate(RefractiveIndex::_vid_w,RefractiveIndex::_vid_h);
-
-    cvConvertorImage.allocate(RefractiveIndex::_vid_w,RefractiveIndex::_vid_h);
 
 }
 
@@ -127,90 +107,27 @@ void CamNoiseAnalysis::acquire()
 
 void CamNoiseAnalysis::synthesise()
 {
-    //cout << "CamNoiseAnalysis::saving synthesis...\n";
+    // we don't need to synthesise
-    if(_state == STATE_STOP) return;
+    return;
     
-    for(float i=1;i<_saved_filenames_analysis.size()-1;i++){
+    /*
      
-        //cout << "CamNoiseAnalysis::synthesis FOR LOOP...\n";
+     //cout << "IResponseAnalysis::saving synthesis...\n";
+     if(_state == STATE_STOP) return;
      
-        //cout << "_saved_filenames_analysis[i]" << _saved_filenames_analysis[i] << endl;
+     _RUN_DONE = false;
      
-        if(_state == STATE_STOP) return;
+     // _saved_filenames_synthesis has processed all the files in the analysis images folder
-
+     while(!_RUN_DONE && _state != STATE_STOP)
-        if(!image1.loadImage(_saved_filenames_analysis[i])){
+     Thread::sleep(3);
-            //couldn't load image
+     */
-            cout << "didn't load image" << endl;
-        }
-
-        if(image1.loadImage(_saved_filenames_analysis[i])){
-            //cout << "LOADED image1!!!" << endl;
-            //if(image5.loadImage(_saved_filenames_analysis[i+1])){
-
-            ///////////////////////// PROCESS THE SAVED CAMERA IMAGES OF SHIT TO THE IMAGES //////////////////////////
-
-            cvColorImage1.setFromPixels(image1.getPixels(), image1.width, image1.height);
-            //cvColorImage2.setFromPixels(image5.getPixels(), image5.width, image5.height);
-
-            cvColorImage1.convertToGrayscalePlanarImage(cvGrayImage1, 1);
-            // cvColorImage2.convertToGrayscalePlanarImage(cvGrayImage2, 1);
-            //added by tom we weren't actually setting cvgrayimage1 anywhere
-           // cvGrayImage1.setFromPixels(cvColorImage1.getPixels(),cvColorImage1.width,cvColorImage1.height);
-            //cvGrayDiff1.absDiff(cvGrayImage2, cvGrayImage1);
-//cvGrayImage1=cvColorImage1;
-
-            cvGrayImage1.erode();
-            cvGrayImage1.erode();
-            cvGrayImage1.erode();
-            cvGrayImage1.blur();
-            cvGrayImage1.contrastStretch();
-           /* cvColorImage1.erode();
-            cvColorImage1.erode();
-            cvColorImage1.erode();
-            cvColorImage1.blur();
-            cvColorImage1.contrastStretch();*/
-
-            /////////////////////////////////// SAVE TO DISK IN THE SYNTHESIS FOLDER ////////////////////////////////
-            string file_name;
-
-            file_name = ofToString(_synth_save_cnt, 2)+"_CamNoiseAnalysis_"+ofToString(_run_cnt,2)+".jpg";
     
 
-            //<---- THE OLD WAY OF SAVING - works on OSX but generates BLACK FRAMES on WINDOWS ---->
-            // ofSaveImage(cvGrayImage1.getPixelsRef(),_whole_file_path_synthesis+"/"+file_name, OF_IMAGE_QUALITY_BEST);
-
-
-            //<---- NEW SAVING - seems to fix WINDOWS saving out BLACK FRAMES PROBLEM ---->
-            //ofImage image;
-            //image.allocate(cvGrayImage1.width, cvGrayImage1.height, OF_IMAGE_GRAYSCALE);
-
-            //*** This needs to be here for OSX of we get a BAD ACCESS ERROR. DOES IT BREAK WINDOWS? ***//
-            //image.setUseTexture(false);
-
-            //image.setFromPixels(cvGrayImage1.getPixels(), cvGrayImage1.width, cvGrayImage1.height, OF_IMAGE_GRAYSCALE);
-            //image.saveImage(_whole_file_path_synthesis+"/"+file_name);
-
-            //_saved_filenames_synthesis.push_back(_whole_file_path_synthesis+"/"+file_name);
-
-            // <--- REALLY NEW SAVING METHOD --- 26 feb 2012 --- consolidated the save function into Abstract Analysis> ///
-            cvConvertorImage.setFromGrayscalePlanarImages(cvGrayImage1,cvGrayImage1,cvGrayImage1);
-            //cvConvertorImage.setFromGrayscalePlanarImages(cvColorImage1,cvColorImage1,cvColorImage1);
-            saveImageSynthesis(file_name, &cvConvertorImage, OF_IMAGE_GRAYSCALE);
-            _synth_save_cnt++;
-
-
-            //}
-        }
-    }
-
-    // _saved_filenames_synthesis has processed all the files in the analysis images folder
-    while(!_RUN_DONE && _state != STATE_STOP)
-        Thread::sleep(3);
 }
 
 void CamNoiseAnalysis::displayresults()
 {
-    for(float i=1;i<_saved_filenames_synthesis.size();i++){
+    for(float i=1;i<_saved_filenames_analysis.size();i++){
         
         if(_state == STATE_STOP) return;
         
@@ -221,13 +138,15 @@ void CamNoiseAnalysis::displayresults()
             //cout << "!_image_shown" << endl;
         }
         
-        if(!image3.loadImage(_saved_filenames_synthesis[i])){
+        _show_image = false;
+        
+        
+        if(!image1.loadImage(_saved_filenames_analysis[i])){
             //couldn't load image
             cout << "didn't load image" << endl;
         } 
         
-        if(image3.loadImage(_saved_filenames_synthesis[i])){
+        if(image1.loadImage(_saved_filenames_analysis[i])){
-            image3.loadImage(_saved_filenames_synthesis[i]);
             //cout << "_show_image = true;" << endl;
             _show_image = true;
             _image_shown = false;
@@ -389,8 +308,6 @@ void CamNoiseAnalysis::draw()
         case STATE_DISPLAY_RESULTS:
         {
 
-            //cout << "STATE_DISPLAY_RESULTS...\n" << endl;
-
             if (_frame_cnt > 2)
             {
                 _image_shown = true;
@@ -399,21 +316,47 @@ void CamNoiseAnalysis::draw()
             
             _frame_cnt++;
             
+            ofEnableAlphaBlending();
+            glShadeModel(GL_SMOOTH);
+            glLineWidth(line_width);
+            glPointSize(point_size);
+            glEnable(GL_POINT_SMOOTH);
+            
+            //RefractiveIndex::cam.begin();
+            
+            ofTranslate(tx, ty, tz);
+            ofRotateX(rx); ofRotateY(ry); ofRotateZ(rz);
+            glScalef(1.5, 1, 1);
+            
             if (_show_image)
-            {
+                image2.setFromPixels(image1.getPixels(), image1.width, image1.height, OF_IMAGE_COLOR);
-                //cout << "_show_image...\n" << endl;
             
-                ofEnableAlphaBlending();
+            image2.bind();        
             
-                ofSetColor(255, 255, 255);
+            RefractiveIndex::_shader.begin();
-                image2.setFromPixels(image3.getPixels(),image3.width,image3.height, OF_IMAGE_COLOR);
-                image2.draw(0,0, ofGetWidth(), ofGetHeight());
             
-                ofDisableAlphaBlending();
+            RefractiveIndex::_shader.setUniform1i("algo", algo);
+            RefractiveIndex::_shader.setUniform1f("scale", scale);
+            RefractiveIndex::_shader.setUniform1i("tex0", 0);
+            
+            switch (draw_style) {
+                case VERTS:
+                    RefractiveIndex::_mesh_vbo.drawVertices();
+                    break;
+                case WIRE:
+                    RefractiveIndex::_mesh_vbo.drawWireframe();
+                    break;
+                case FACE:
+                    RefractiveIndex::_mesh_vbo.drawFaces();
+                    break;            
             }
             
-            // display results of the synthesis
+            RefractiveIndex::_shader.end();                
-            _RUN_DONE = true;
+            
+            image2.unbind();
+            
+            //RefractiveIndex::cam.end();    
+            
             break;
 
         }

src/CamNoiseAnalysis.h

@@ -37,31 +37,13 @@ protected:
     float   c, _frame_cnt, _frame_cnt_max, _anim_cnt_max;
     
     bool _show_image, _image_shown;
+    
     ofImage         image1;
     ofImage         image2; 
-    ofImage         image3;
-    ofImage         image4;
-    ofImage         image5; 
-    ofImage         image6; 
-    
-    ofxCvColorImage         cvColorImage1;
-    ofxCvColorImage         cvColorImage2;
-    ofxCvColorImage         cvColorImage3;
-    ofxCvColorImage         cvColorImage4;
-    ofxCvColorImage         cvColorImage5;
-    ofxCvColorImage         cvColorImage6;
-    
-    ofxCvGrayscaleImage 	cvGrayDiff1;
-    ofxCvGrayscaleImage 	cvGrayDiff2;
-    
-    ofxCvGrayscaleImage 	cvGrayImage1;
-    ofxCvGrayscaleImage 	cvGrayImage2;
-    ofxCvGrayscaleImage 	cvGrayImage3;
-    ofxCvGrayscaleImage 	cvGrayImage4;
-    
-    ofxCvContourFinder      cvContourFinder1;
-    
-    //this is the temporary container to allow us to convert and save out greyscale images
-    ofxCvColorImage         cvConvertorImage;
     
+    int algo;
+    int scale;
+    int draw_style;   
+    float line_width;
+    float point_size;    
 };

src/ColorMultiAnalysis.cpp

@@ -12,6 +12,11 @@ using Poco::Thread;
 #define NUMBER_RUNS     1
 #define ACQUIRE_TIME    20
 
+const int algo_default = 1;
+const int scale_default = 500;
+const int draw_style_default = 3;
+const float line_width_default = 0.5f;
+
 void ColorMultiAnalysis::setup(int camWidth, int camHeight)
 {
     AbstractAnalysis::setup(camWidth, camHeight);
@@ -46,50 +51,21 @@ void ColorMultiAnalysis::setup(int camWidth, int camHeight)
     
     image1.clear();
     image2.clear();
-    image3.clear();  
-    image4.clear();
-    image5.clear();
     
     //  images use for drawing the synthesized files to the screen ///
     image1.setUseTexture(false);  // the non texture image that is needed to first load the image
     image2.setUseTexture(true);   // the image that needs to get written to the screen which takes the content of image1
     
-    //  images used for re-loading and saving out the synthesized files ///
-    image3.setUseTexture(false);  
-    image4.setUseTexture(false);
-    image5.setUseTexture(false);
-    
     image1.allocate(RefractiveIndex::_vid_w,RefractiveIndex::_vid_h,  OF_IMAGE_COLOR);
     image2.allocate(RefractiveIndex::_vid_w,RefractiveIndex::_vid_h,  OF_IMAGE_COLOR);
-    image3.allocate(RefractiveIndex::_vid_w,RefractiveIndex::_vid_h,  OF_IMAGE_COLOR);  
-    image4.allocate(RefractiveIndex::_vid_w,RefractiveIndex::_vid_h,  OF_IMAGE_COLOR);
-    image5.allocate(RefractiveIndex::_vid_w,RefractiveIndex::_vid_h,  OF_IMAGE_COLOR);
     
-    //cout << "RefractiveIndex::_vid_w " << RefractiveIndex::_vid_w << endl;
-    //cout << "RefractiveIndex::_vid_h " << RefractiveIndex::_vid_h << endl;
     
-    // clear() apparently fixes the "OF_WARNING: in allocate, reallocating a ofxCvImage" 
+    ////---------
-    // that we're getting in OSX/Windows and is maybe crashing Windows
-    // http://forum.openframeworks.cc/index.php?topic=1867.0
-    cvColorImage1.clear();
-	cvGrayImage1.clear();
-    cvGrayDiff1.clear();
     
-    cvColorImage2.clear();
+    algo = RefractiveIndex::XML.getValue("config:algorithms:colormulti:algo", algo_default);
-	cvGrayImage2.clear();
+    scale = RefractiveIndex::XML.getValue("config:algorithms:colormulti:scale", scale_default);
-    cvGrayDiff2.clear();
+    draw_style = RefractiveIndex::XML.getValue("config:algorithms:colormulti:draw_style", draw_style_default);
-    
+    line_width = RefractiveIndex::XML.getValue("config:algorithms:colormulti:line_width", line_width_default);
-    cvConvertorImage.clear();    
-    
-    cvColorImage1.allocate(RefractiveIndex::_vid_w,RefractiveIndex::_vid_h);
-	cvGrayImage1.allocate(RefractiveIndex::_vid_w,RefractiveIndex::_vid_h);
-    cvGrayDiff1.allocate(RefractiveIndex::_vid_w,RefractiveIndex::_vid_h);
-    
-    cvColorImage2.allocate(RefractiveIndex::_vid_w,RefractiveIndex::_vid_h);
-	cvGrayImage2.allocate(RefractiveIndex::_vid_w,RefractiveIndex::_vid_h);
-    cvGrayDiff2.allocate(RefractiveIndex::_vid_w,RefractiveIndex::_vid_h);
-    
-    cvConvertorImage.allocate(RefractiveIndex::_vid_w,RefractiveIndex::_vid_h);
 
 }
 
@@ -125,79 +101,25 @@ void ColorMultiAnalysis::acquire()
 void ColorMultiAnalysis::synthesise()
 {
     
-    //cout << "ColorMultiAnalysis::saving synthesis...\n";
+    // we don't need to synthesise
-    if(_state == STATE_STOP) return;
+    return;
     
-    for(float i=1;i<_saved_filenames_analysis.size()-1;i++){
+    /*
      
-        //cout << "ColorMultiAnalysis::synthesis FOR LOOP...\n";
+     //cout << "IResponseAnalysis::saving synthesis...\n";
+     if(_state == STATE_STOP) return;
      
-        //cout << "_saved_filenames_analysis[i]" << _saved_filenames_analysis[i] << endl;
+     _RUN_DONE = false;
      
-        if(_state == STATE_STOP) return;
+     // _saved_filenames_synthesis has processed all the files in the analysis images folder
-        
+     while(!_RUN_DONE && _state != STATE_STOP)
-        if(!image1.loadImage(_saved_filenames_analysis[i])){
+     Thread::sleep(3);
-            //couldn't load image
+     */
-            cout << "didn't load image" << endl;
-        } 
-        
-        if(image1.loadImage(_saved_filenames_analysis[i])){
-            //cout << "LOADED image1!!!" << endl;
-            //if(image5.loadImage(_saved_filenames_analysis[i+1])){
-            
-            ///////////////////////// PROCESS THE SAVED CAMERA IMAGES OF SHIT TO THE IMAGES //////////////////////////
-            
-            cvColorImage1.setFromPixels(image1.getPixels(), image1.width, image1.height);
-            //cvColorImage2.setFromPixels(image5.getPixels(), image5.width, image5.height);
-            
-            cvColorImage1.blur(5);
-            cvColorImage1.erode();
-            cvColorImage1.erode();
-            cvColorImage1.dilate();
-            cvColorImage1.blur(5);
-            cvColorImage1.dilate();
-            cvColorImage1.dilate();
-            cvColorImage1.dilate();
-            cvColorImage1.dilate();
-            
-            /////////////////////////////////// SAVE TO DISK IN THE SYNTHESIS FOLDER ////////////////////////////////
-            string file_name;
-            
-            file_name = ofToString(_synth_save_cnt, 2)+"_ColorMultiAnalysis_"+ofToString(_run_cnt,2)+".jpg";
-            
-            
-            //<---- THE OLD WAY OF SAVING - works on OSX but generates BLACK FRAMES on WINDOWS ---->
-            // ofSaveImage(cvGrayImage1.getPixelsRef(),_whole_file_path_synthesis+"/"+file_name, OF_IMAGE_QUALITY_BEST);
-            
-            
-            //<---- NEW SAVING - seems to fix WINDOWS saving out BLACK FRAMES PROBLEM ---->
-            //ofImage image;
-            //image.allocate(cvColorImage1.width, cvColorImage1.height, OF_IMAGE_COLOR);
-            
-            //*** This needs to be here for OSX of we get a BAD ACCESS ERROR. DOES IT BREAK WINDOWS? ***//
-            //image.setUseTexture(false);  
-           
-            //image.setFromPixels(cvColorImage1.getPixels(), cvColorImage1.width, cvColorImage1.height,OF_IMAGE_COLOR);
-            //image.saveImage(_whole_file_path_synthesis+"/"+file_name);
-            
-            //_saved_filenames_synthesis.push_back(_whole_file_path_synthesis+"/"+file_name);
-            
-            // <--- REALLY NEW SAVING METHOD --- 26 feb 2012 --- consolidated the save function into Abstract Analysis> ///
-            saveImageSynthesis(file_name, &cvColorImage1, OF_IMAGE_COLOR);
-            _synth_save_cnt++;
-            
-            // }
-        }
-    }
-    
-    // _saved_filenames_synthesis has processed all the files in the analysis images folder
-    while(!_RUN_DONE && _state != STATE_STOP)
-        Thread::sleep(3);
 }
 
 void ColorMultiAnalysis::displayresults()
 {
-    for(float i=1;i<_saved_filenames_synthesis.size();i++){
+    for(float i=1;i<_saved_filenames_analysis.size();i++){
         
         if(_state == STATE_STOP) return;
         
@@ -208,13 +130,15 @@ void ColorMultiAnalysis::displayresults()
             //cout << "!_image_shown" << endl;
         }
         
-        if(!image3.loadImage(_saved_filenames_synthesis[i])){
+        _show_image = false;
+        
+        
+        if(!image1.loadImage(_saved_filenames_analysis[i])){
             //couldn't load image
             cout << "didn't load image" << endl;
         } 
         
-        if(image3.loadImage(_saved_filenames_synthesis[i])){
+        if(image1.loadImage(_saved_filenames_analysis[i])){
-            image3.loadImage(_saved_filenames_synthesis[i]);
             //cout << "_show_image = true;" << endl;
             _show_image = true;
             _image_shown = false;
@@ -356,8 +280,9 @@ void ColorMultiAnalysis::draw()
                 _anim_cnt++;
                 
             } else {
-                _state = STATE_DISPLAY_RESULTS;
+                //_state = STATE_DISPLAY_RESULTS;
                 _anim_cnt=0;
+                _RUN_DONE = true;
             }
             ofPopMatrix();
             ofSetRectMode(OF_RECTMODE_CORNER);
@@ -371,7 +296,6 @@ void ColorMultiAnalysis::draw()
             
             //cout << "STATE_DISPLAY_RESULTS...\n" << endl;
             
-            
             if (_frame_cnt > 2)
             {
                 _image_shown = true;
@@ -380,22 +304,48 @@ void ColorMultiAnalysis::draw()
             
             _frame_cnt++;
             
-            if (_show_image)
-            {  
-                //cout << "_show_image...\n" << endl;
                 
-                ofEnableAlphaBlending();
+            ofEnableAlphaBlending();
+            glShadeModel(GL_SMOOTH);
+            glLineWidth(line_width);              
                 
-                ofSetColor(255, 255, 255);
+                //RefractiveIndex::cam.begin();
-                image2.setFromPixels(image3.getPixels(),image3.width,image3.height, OF_IMAGE_COLOR);
-                image2.draw(0,0, ofGetWidth(), ofGetHeight());
                 
-                ofDisableAlphaBlending();
+                ofTranslate(tx, ty, tz);
-            }
+                ofRotateX(rx); ofRotateY(ry); ofRotateZ(rz);
+                glScalef(1.5, 1, 1);
                 
-            // display results of the synthesis
+                if (_show_image)
-            _RUN_DONE = true;
+                    image2.setFromPixels(image1.getPixels(), image1.width, image1.height, OF_IMAGE_COLOR);
-            break;
+                                
+                image2.bind();        
+                
+                RefractiveIndex::_shader.begin();
+                
+                RefractiveIndex::_shader.setUniform1i("algo", algo);
+                RefractiveIndex::_shader.setUniform1f("scale", scale);
+                RefractiveIndex::_shader.setUniform1i("tex0", 0);
+                                
+                switch (draw_style) {
+                    case VERTS:
+                        RefractiveIndex::_mesh_vbo.drawVertices();
+                        break;
+                    case WIRE:
+                        RefractiveIndex::_mesh_vbo.drawWireframe();
+                        break;
+                    case FACE:
+                        RefractiveIndex::_mesh_vbo.drawFaces();
+                        break;            
+                }
+                
+                RefractiveIndex::_shader.end();                
+                
+                image2.unbind();
+                
+                //RefractiveIndex::cam.end();    
+                
+                _RUN_DONE = true;
+                break;
             
         }
             

src/ColorMultiAnalysis.h

@@ -31,32 +31,14 @@ protected:
     float   c, _frame_cnt, _frame_cnt_max, _anim_cnt_max;
 
     bool _show_image, _image_shown;
+    
     ofImage         image1;
     ofImage         image2; 
-    ofImage         image3;
-    ofImage         image4;
-    ofImage         image5; 
-    ofImage         image6; 
     
-    ofxCvColorImage         cvColorImage1;
+    int algo;
-    ofxCvColorImage         cvColorImage2;
+    int scale;
-    ofxCvColorImage         cvColorImage3;
+    int draw_style;
-    ofxCvColorImage         cvColorImage4;
+    float line_width;
-    ofxCvColorImage         cvColorImage5;
-    ofxCvColorImage         cvColorImage6;
-    
-    ofxCvGrayscaleImage 	cvGrayDiff1;
-    ofxCvGrayscaleImage 	cvGrayDiff2;
-    
-    ofxCvGrayscaleImage 	cvGrayImage1;
-    ofxCvGrayscaleImage 	cvGrayImage2;
-    ofxCvGrayscaleImage 	cvGrayImage3;
-    ofxCvGrayscaleImage 	cvGrayImage4;
-    
-    ofxCvContourFinder      cvContourFinder1;
-    
-    //this is the temporary container to allow us to convert and save out greyscale images
-    ofxCvColorImage         cvConvertorImage;
     
 
 };

src/ColorSingleAnalysis.cpp

@@ -13,6 +13,11 @@ using Poco::Thread;
 #define NUMBER_RUNS     1
 #define ACQUIRE_TIME    20
 
+const int algo_default = 1;
+const int scale_default = 500;
+const int draw_style_default = 3;
+const float line_width_default = 0.5f;
+
 void ColorSingleAnalysis::setup(int camWidth, int camHeight)
 {
     AbstractAnalysis::setup(camWidth, camHeight);
@@ -53,50 +58,21 @@ void ColorSingleAnalysis::setup(int camWidth, int camHeight)
     
     image1.clear();
     image2.clear();
-    image3.clear();  
-    image4.clear();
-    image5.clear();
     
     //  images use for drawing the synthesized files to the screen ///
     image1.setUseTexture(false);  // the non texture image that is needed to first load the image
     image2.setUseTexture(true);   // the image that needs to get written to the screen which takes the content of image1
     
-    //  images used for re-loading and saving out the synthesized files ///
-    image3.setUseTexture(false);  
-    image4.setUseTexture(false);
-    image5.setUseTexture(false);
-    
     image1.allocate(RefractiveIndex::_vid_w,RefractiveIndex::_vid_h,  OF_IMAGE_COLOR);
     image2.allocate(RefractiveIndex::_vid_w,RefractiveIndex::_vid_h,  OF_IMAGE_COLOR);
-    image3.allocate(RefractiveIndex::_vid_w,RefractiveIndex::_vid_h,  OF_IMAGE_COLOR);  
-    image4.allocate(RefractiveIndex::_vid_w,RefractiveIndex::_vid_h,  OF_IMAGE_COLOR);
-    image5.allocate(RefractiveIndex::_vid_w,RefractiveIndex::_vid_h,  OF_IMAGE_COLOR);
     
-    //cout << "RefractiveIndex::_vid_w " << RefractiveIndex::_vid_w << endl;
-    //cout << "RefractiveIndex::_vid_h " << RefractiveIndex::_vid_h << endl;
     
-    // clear() apparently fixes the "OF_WARNING: in allocate, reallocating a ofxCvImage" 
+    ////---------
-    // that we're getting in OSX/Windows and is maybe crashing Windows
-    // http://forum.openframeworks.cc/index.php?topic=1867.0
-    cvColorImage1.clear();
-	cvGrayImage1.clear();
-    cvGrayDiff1.clear();
     
-    cvColorImage2.clear();
+    algo = RefractiveIndex::XML.getValue("config:algorithms:colorsingle:algo", algo_default);
-	cvGrayImage2.clear();
+    scale = RefractiveIndex::XML.getValue("config:algorithms:colorsingle:scale", scale_default);
-    cvGrayDiff2.clear();
+    draw_style = RefractiveIndex::XML.getValue("config:algorithms:colorsingle:draw_style", draw_style_default);
-    
+    line_width = RefractiveIndex::XML.getValue("config:algorithms:colorsingle:line_width", line_width_default);
-    cvConvertorImage.clear();    
-    
-    cvColorImage1.allocate(RefractiveIndex::_vid_w,RefractiveIndex::_vid_h);
-	cvGrayImage1.allocate(RefractiveIndex::_vid_w,RefractiveIndex::_vid_h);
-    cvGrayDiff1.allocate(RefractiveIndex::_vid_w,RefractiveIndex::_vid_h);
-    
-    cvColorImage2.allocate(RefractiveIndex::_vid_w,RefractiveIndex::_vid_h);
-	cvGrayImage2.allocate(RefractiveIndex::_vid_w,RefractiveIndex::_vid_h);
-    cvGrayDiff2.allocate(RefractiveIndex::_vid_w,RefractiveIndex::_vid_h);
-    
-    cvConvertorImage.allocate(RefractiveIndex::_vid_w,RefractiveIndex::_vid_h);
     
 }
 
@@ -133,81 +109,26 @@ void ColorSingleAnalysis::acquire()
 void ColorSingleAnalysis::synthesise()
 {
     
-    //cout << "ColorSingleAnalysis::saving synthesis...\n";
+    // we don't need to synthesise
-    if(_state == STATE_STOP) return;
+    return;
     
-    for(float i=1;i<_saved_filenames_analysis.size()-1;i++){
+    /*
      
-        //cout << "ColorSingleAnalysis::synthesis FOR LOOP...\n";
+     //cout << "IResponseAnalysis::saving synthesis...\n";
+     if(_state == STATE_STOP) return;
      
-        //cout << "_saved_filenames_analysis[i]" << _saved_filenames_analysis[i] << endl;
+     _RUN_DONE = false;
      
-        if(_state == STATE_STOP) return;
+     // _saved_filenames_synthesis has processed all the files in the analysis images folder
-        
+     while(!_RUN_DONE && _state != STATE_STOP)
-        if(!image1.loadImage(_saved_filenames_analysis[i])){
+     Thread::sleep(3);
-            //couldn't load image
+     */
-            cout << "didn't load image" << endl;
-        } 
-        
-        if(image1.loadImage(_saved_filenames_analysis[i])){
-            //cout << "LOADED image1!!!" << endl;
-            //if(image5.loadImage(_saved_filenames_analysis[i+1])){
-                
-                ///////////////////////// PROCESS THE SAVED CAMERA IMAGES OF SHIT TO THE IMAGES //////////////////////////
-                
-                cvColorImage1.setFromPixels(image1.getPixels(), image1.width, image1.height);
-                //cvColorImage2.setFromPixels(image5.getPixels(), image5.width, image5.height);
-                
-                cvColorImage1.blur(5);
-                cvColorImage1.erode();
-                cvColorImage1.erode();
-                cvColorImage1.dilate();
-                cvColorImage1.blur(5);
-                cvColorImage1.erode();
-                cvColorImage1.erode();
-                cvColorImage1.erode();
-                cvColorImage1.erode();
-            
-                /////////////////////////////////// SAVE TO DISK IN THE SYNTHESIS FOLDER ////////////////////////////////
-                string file_name;
-                
-                file_name = ofToString(_synth_save_cnt, 2)+"_ColorSingleAnalysis_"+ofToString(_run_cnt,2)+".jpg";
-                
-                
-                //<---- THE OLD WAY OF SAVING - works on OSX but generates BLACK FRAMES on WINDOWS ---->
-                // ofSaveImage(cvGrayImage1.getPixelsRef(),_whole_file_path_synthesis+"/"+file_name, OF_IMAGE_QUALITY_BEST);
-                
-                
-                //<---- NEW SAVING - seems to fix WINDOWS saving out BLACK FRAMES PROBLEM ---->
-                //ofImage image;
-                //image.allocate(cvColorImage1.width, cvColorImage1.height, OF_IMAGE_COLOR);
-                
-                //*** This needs to be here for OSX of we get a BAD ACCESS ERROR. DOES IT BREAK WINDOWS? ***//
-                //image.setUseTexture(false);  
-                
-                //image.setFromPixels(cvColorImage1.getPixels(), cvColorImage1.width, cvColorImage1.height,OF_IMAGE_COLOR);
-                //image.saveImage(_whole_file_path_synthesis+"/"+file_name);
-            
-                //_saved_filenames_synthesis.push_back(_whole_file_path_synthesis+"/"+file_name);
-                
-                // <--- REALLY NEW SAVING METHOD --- 26 feb 2012 --- consolidated the save function into Abstract Analysis> ///
-            
-                saveImageSynthesis(file_name, &cvColorImage1, OF_IMAGE_COLOR);
-                _synth_save_cnt++;
-            
-           // }
-        }
-    }
-    
-    // _saved_filenames_synthesis has processed all the files in the analysis images folder
-    while(!_RUN_DONE && _state != STATE_STOP)
-        Thread::sleep(3);
     
 }
 
 void ColorSingleAnalysis::displayresults()
 {
-    for(float i=1;i<_saved_filenames_synthesis.size();i++){
+    for(float i=1;i<_saved_filenames_analysis.size();i++){
         
         if(_state == STATE_STOP) return;
         
@@ -218,13 +139,15 @@ void ColorSingleAnalysis::displayresults()
             //cout << "!_image_shown" << endl;
         }
         
-        if(!image3.loadImage(_saved_filenames_synthesis[i])){
+        _show_image = false;
+        
+        
+        if(!image1.loadImage(_saved_filenames_analysis[i])){
             //couldn't load image
             cout << "didn't load image" << endl;
         } 
         
-        if(image3.loadImage(_saved_filenames_synthesis[i])){
+        if(image1.loadImage(_saved_filenames_analysis[i])){
-            image3.loadImage(_saved_filenames_synthesis[i]);
             //cout << "_show_image = true;" << endl;
             _show_image = true;
             _image_shown = false;
@@ -389,7 +312,6 @@ void ColorSingleAnalysis::draw()
             
             //cout << "STATE_DISPLAY_RESULTS...\n" << endl;
             
-            
             if (_frame_cnt > 2)
             {
                 _image_shown = true;
@@ -398,20 +320,46 @@ void ColorSingleAnalysis::draw()
             
             _frame_cnt++;
             
+            
+            ofEnableAlphaBlending();
+            glShadeModel(GL_SMOOTH);
+            glLineWidth(line_width);              
+            
+            //RefractiveIndex::cam.begin();
+            
+            ofTranslate(tx, ty, tz);
+            ofRotateX(rx); ofRotateY(ry); ofRotateZ(rz);
+            glScalef(1.5, 1, 1);
+            
             if (_show_image)
-            {  
+                image2.setFromPixels(image1.getPixels(), image1.width, image1.height, OF_IMAGE_COLOR);
-                //cout << "_show_image...\n" << endl;
             
-                ofEnableAlphaBlending();
+            image2.bind();        
             
-                ofSetColor(255, 255, 255);
+            RefractiveIndex::_shader.begin();
-                image2.setFromPixels(image3.getPixels(),image3.width,image3.height, OF_IMAGE_COLOR);
-                image2.draw(0,0, ofGetWidth(), ofGetHeight());
             
-                ofDisableAlphaBlending();
+            RefractiveIndex::_shader.setUniform1i("algo", algo);
+            RefractiveIndex::_shader.setUniform1f("scale", scale);
+            RefractiveIndex::_shader.setUniform1i("tex0", 0);
+            
+            switch (draw_style) {
+                case VERTS:
+                    RefractiveIndex::_mesh_vbo.drawVertices();
+                    break;
+                case WIRE:
+                    RefractiveIndex::_mesh_vbo.drawWireframe();
+                    break;
+                case FACE:
+                    RefractiveIndex::_mesh_vbo.drawFaces();
+                    break;            
             }
             
-            // display results of the synthesis
+            RefractiveIndex::_shader.end();                
+            
+            image2.unbind();
+            
+            //RefractiveIndex::cam.end();    
+            
             _RUN_DONE = true;
             break;
 

src/ColorSingleAnalysis.h

@@ -38,32 +38,13 @@ protected:
     float   c, _frame_cnt, _frame_cnt_max, _anim_cnt_max;
     
     bool _show_image, _image_shown;
+
     ofImage         image1;
     ofImage         image2; 
-    ofImage         image3;
-    ofImage         image4;
-    ofImage         image5; 
-    ofImage         image6; 
-    
-    ofxCvColorImage         cvColorImage1;
-    ofxCvColorImage         cvColorImage2;
-    ofxCvColorImage         cvColorImage3;
-    ofxCvColorImage         cvColorImage4;
-    ofxCvColorImage         cvColorImage5;
-    ofxCvColorImage         cvColorImage6;
-    
-    ofxCvGrayscaleImage 	cvGrayDiff1;
-    ofxCvGrayscaleImage 	cvGrayDiff2;
-    
-    ofxCvGrayscaleImage 	cvGrayImage1;
-    ofxCvGrayscaleImage 	cvGrayImage2;
-    ofxCvGrayscaleImage 	cvGrayImage3;
-    ofxCvGrayscaleImage 	cvGrayImage4;
-    
-    ofxCvContourFinder      cvContourFinder1;
-    
-    //this is the temporary container to allow us to convert and save out greyscale images
-    ofxCvColorImage         cvConvertorImage;
     
+    int algo;
+    int scale;
+    int draw_style;
+    float line_width;    
 
 };

src/DiffNoiseAnalysis.cpp

@@ -13,6 +13,12 @@ using Poco::Thread;
 #define NUMBER_RUNS     1
 #define ACQUIRE_TIME    20
 
+const int algo_default = 1;
+const int scale_default = 500;
+const int draw_style_default = 3;
+const int line_width_default = 0.5f;
+const float point_size_default = 0.5f;
+
 void DiffNoiseAnalysis::setup(int camWidth, int camHeight)
 {
     AbstractAnalysis::setup(camWidth, camHeight);
@@ -47,50 +53,22 @@ void DiffNoiseAnalysis::setup(int camWidth, int camHeight)
     
     image1.clear();
     image2.clear();
-    image3.clear();  
-    image4.clear();
-    image5.clear();
     
     //  images use for drawing the synthesized files to the screen ///
     image1.setUseTexture(false);  // the non texture image that is needed to first load the image
     image2.setUseTexture(true);   // the image that needs to get written to the screen which takes the content of image1
     
-    //  images used for re-loading and saving out the synthesized files ///
-    image3.setUseTexture(false);  
-    image4.setUseTexture(false);
-    image5.setUseTexture(false);
-    
     image1.allocate(RefractiveIndex::_vid_w,RefractiveIndex::_vid_h,  OF_IMAGE_COLOR);
     image2.allocate(RefractiveIndex::_vid_w,RefractiveIndex::_vid_h,  OF_IMAGE_COLOR);
-    image3.allocate(RefractiveIndex::_vid_w,RefractiveIndex::_vid_h,  OF_IMAGE_COLOR);  
-    image4.allocate(RefractiveIndex::_vid_w,RefractiveIndex::_vid_h,  OF_IMAGE_COLOR);
-    image5.allocate(RefractiveIndex::_vid_w,RefractiveIndex::_vid_h,  OF_IMAGE_COLOR);
     
-    //cout << "RefractiveIndex::_vid_w " << RefractiveIndex::_vid_w << endl;
-    //cout << "RefractiveIndex::_vid_h " << RefractiveIndex::_vid_h << endl;
     
-    // clear() apparently fixes the "OF_WARNING: in allocate, reallocating a ofxCvImage" 
+    ////---------
-    // that we're getting in OSX/Windows and is maybe crashing Windows
-    // http://forum.openframeworks.cc/index.php?topic=1867.0
-    cvColorImage1.clear();
-	cvGrayImage1.clear();
-    cvGrayDiff1.clear();
     
-    cvColorImage2.clear();
+    algo = RefractiveIndex::XML.getValue("config:algorithms:diffnoise:algo", algo_default);
-	cvGrayImage2.clear();
+    scale = RefractiveIndex::XML.getValue("config:algorithms:diffnoise:scale", scale_default);
-    cvGrayDiff2.clear();
+    draw_style = RefractiveIndex::XML.getValue("config:algorithms:diffnoise:draw_style", draw_style_default);
-    
+    line_width = RefractiveIndex::XML.getValue("config:algorithms:diffnoise:line_width", line_width_default);        
-    cvConvertorImage.clear();    
+    point_size = RefractiveIndex::XML.getValue("config:algorithms:diffnoise:point_size", point_size_default);
-    
-    cvColorImage1.allocate(RefractiveIndex::_vid_w,RefractiveIndex::_vid_h);
-	cvGrayImage1.allocate(RefractiveIndex::_vid_w,RefractiveIndex::_vid_h);
-    cvGrayDiff1.allocate(RefractiveIndex::_vid_w,RefractiveIndex::_vid_h);
-    
-    cvColorImage2.allocate(RefractiveIndex::_vid_w,RefractiveIndex::_vid_h);
-	cvGrayImage2.allocate(RefractiveIndex::_vid_w,RefractiveIndex::_vid_h);
-    cvGrayDiff2.allocate(RefractiveIndex::_vid_w,RefractiveIndex::_vid_h);
-    
-    cvConvertorImage.allocate(RefractiveIndex::_vid_w,RefractiveIndex::_vid_h);
     
 }
 
@@ -126,79 +104,27 @@ void DiffNoiseAnalysis::acquire()
 void DiffNoiseAnalysis::synthesise()
 {   
     
-    //cout << "DiffNoiseAnalysis::saving synthesis...\n";
+    // we don't need to synthesise
-    if(_state == STATE_STOP) return;
+    return;
     
-    for(float i=1;i<_saved_filenames_analysis.size()-1;i++){
+    /*
      
-        //cout << "DiffNoiseAnalysis::synthesis FOR LOOP...\n";
+     //cout << "IResponseAnalysis::saving synthesis...\n";
+     if(_state == STATE_STOP) return;
      
-        //cout << "_saved_filenames_analysis[i]" << _saved_filenames_analysis[i] << endl;
+     _RUN_DONE = false;
      
-        if(_state == STATE_STOP) return;
+     // _saved_filenames_synthesis has processed all the files in the analysis images folder
-        
+     while(!_RUN_DONE && _state != STATE_STOP)
-        if(!image1.loadImage(_saved_filenames_analysis[i])){
+     Thread::sleep(3);
-            //couldn't load image
+     */
-            cout << "didn't load image" << endl;
-        } 
-        
-        if(image1.loadImage(_saved_filenames_analysis[i])){
-            //cout << "LOADED image1!!!" << endl;
-            //if(image5.loadImage(_saved_filenames_analysis[i+1])){
-            
-            ///////////////////////// PROCESS THE SAVED CAMERA IMAGES OF SHIT TO THE IMAGES //////////////////////////
-            
-            cvColorImage1.setFromPixels(image1.getPixels(), image1.width, image1.height);
-            //cvColorImage2.setFromPixels(image5.getPixels(), image5.width, image5.height);
-        
-            cvColorImage1.invert();
-            cvColorImage1.blur(5);
-            cvColorImage1.erode();
-            cvColorImage1.erode();
-            cvColorImage1.blur(5);
-            cvColorImage1.erode();
-            cvColorImage1.erode();
-            
-            //////////////////////////// SAVE TO DISK IN THE SYNTHESIS FOLDER ////////////////////////////////
-            string file_name;
-            
-            file_name = ofToString(_synth_save_cnt, 2)+"_DiffNoiseAnalysis_"+ofToString(_run_cnt,2)+".jpg";
-            
-            
-            //<---- THE OLD WAY OF SAVING - works on OSX but generates BLACK FRAMES on WINDOWS ---->
-            // ofSaveImage(cvGrayImage1.getPixelsRef(),_whole_file_path_synthesis+"/"+file_name, OF_IMAGE_QUALITY_BEST);
-            
-            
-            //<---- NEW SAVING - seems to fix WINDOWS saving out BLACK FRAMES PROBLEM ---->
-            //ofImage image;
-            //image.allocate(cvColorImage1.width, cvGrayImage1.height, OF_IMAGE_COLOR);
-            
-            //*** This needs to be here for OSX of we get a BAD ACCESS ERROR. DOES IT BREAK WINDOWS? ***//
-            //image.setUseTexture(false);  
-            
-            //image.setFromPixels(cvColorImage1.getPixels(), cvColorImage1.width, cvColorImage1.height, OF_IMAGE_COLOR);
-            //image.saveImage(_whole_file_path_synthesis+"/"+file_name);
-            
-            //_saved_filenames_synthesis.push_back(_whole_file_path_synthesis+"/"+file_name);
-            
-            // <--- REALLY NEW SAVING METHOD --- 26 feb 2012 --- consolidated the save function into Abstract Analysis> ///
-            saveImageSynthesis(file_name, &cvColorImage1, OF_IMAGE_COLOR);
-            _synth_save_cnt++;
-            
-            // }
-        }
-    }
-    
-    // _saved_filenames_synthesis has processed all the files in the analysis images folder
-    while(!_RUN_DONE && _state != STATE_STOP)
-        Thread::sleep(3);
     
 }
 
 void DiffNoiseAnalysis::displayresults()
 {
     
-    for(float i=1;i<_saved_filenames_synthesis.size();i++){
+    for(float i=1;i<_saved_filenames_analysis.size();i++){
         
         if(_state == STATE_STOP) return;
         
@@ -209,20 +135,21 @@ void DiffNoiseAnalysis::displayresults()
             //cout << "!_image_shown" << endl;
         }
         
-        if(!image3.loadImage(_saved_filenames_synthesis[i])){
+        _show_image = false;
+        
+        
+        if(!image1.loadImage(_saved_filenames_analysis[i])){
             //couldn't load image
             cout << "didn't load image" << endl;
         } 
         
-        if(image3.loadImage(_saved_filenames_synthesis[i])){
+        if(image1.loadImage(_saved_filenames_analysis[i])){
-            image3.loadImage(_saved_filenames_synthesis[i]);
             //cout << "_show_image = true;" << endl;
             _show_image = true;
             _image_shown = false;
         }
     }         
     
-    
 }
 
 
@@ -392,9 +319,6 @@ void DiffNoiseAnalysis::draw()
             
         case STATE_DISPLAY_RESULTS:
         {
-            //cout << "STATE_DISPLAY_RESULTS...\n" << endl;
-            
-            
             if (_frame_cnt > 2)
             {
                 _image_shown = true;
@@ -403,22 +327,47 @@ void DiffNoiseAnalysis::draw()
             
             _frame_cnt++;
             
+            ofEnableAlphaBlending();
+            glShadeModel(GL_SMOOTH);
+            glLineWidth(line_width);
+            glPointSize(point_size);
+            glEnable(GL_POINT_SMOOTH);
+            
+            //RefractiveIndex::cam.begin();
+            
+            ofTranslate(tx, ty, tz);
+            ofRotateX(rx); ofRotateY(ry); ofRotateZ(rz);
+            glScalef(1.5, 1, 1);
+            
             if (_show_image)
-            {  
+                image2.setFromPixels(image1.getPixels(), image1.width, image1.height, OF_IMAGE_COLOR);
-                //cout << "_show_image...\n" << endl;
             
-                ofEnableAlphaBlending();
+            image2.bind();        
             
-                ofSetColor(255, 255, 255);
+            RefractiveIndex::_shader.begin();
-                image2.setFromPixels(image3.getPixels(),image3.width,image3.height, OF_IMAGE_COLOR);
-                //image2.setFromPixels(image3.getPixels(),image3.width,image3.height, OF_IMAGE_GRAYSCALE);
-                image2.draw(0,0, ofGetWidth(), ofGetHeight());
             
-                ofDisableAlphaBlending();
+            RefractiveIndex::_shader.setUniform1i("algo", algo);
+            RefractiveIndex::_shader.setUniform1f("scale", scale);
+            RefractiveIndex::_shader.setUniform1i("tex0", 0);
+            
+            switch (draw_style) {
+                case VERTS:
+                    RefractiveIndex::_mesh_vbo.drawVertices();
+                    break;
+                case WIRE:
+                    RefractiveIndex::_mesh_vbo.drawWireframe();
+                    break;
+                case FACE:
+                    RefractiveIndex::_mesh_vbo.drawFaces();
+                    break;            
             }
             
-            // display results of the synthesis
+            RefractiveIndex::_shader.end();                
-            _RUN_DONE = true;
+            
+            image2.unbind();
+            
+            //RefractiveIndex::cam.end();    
+            
             break;
             
         }

src/DiffNoiseAnalysis.h

@@ -36,31 +36,14 @@ protected:
     float   c, _frame_cnt, _frame_cnt_max, _anim_cnt_max;
     
     bool _show_image, _image_shown;
+    
     ofImage         image1;
     ofImage         image2; 
-    ofImage         image3;
-    ofImage         image4;
-    ofImage         image5; 
-    ofImage         image6; 
     
-    ofxCvColorImage         cvColorImage1;
+    int algo;
-    ofxCvColorImage         cvColorImage2;
+    int scale;
-    ofxCvColorImage         cvColorImage3;
+    int draw_style;   
-    ofxCvColorImage         cvColorImage4;
+    float line_width;
-    ofxCvColorImage         cvColorImage5;
+    float point_size;
-    ofxCvColorImage         cvColorImage6;
-    
-    ofxCvGrayscaleImage 	cvGrayDiff1;
-    ofxCvGrayscaleImage 	cvGrayDiff2;
-    
-    ofxCvGrayscaleImage 	cvGrayImage1;
-    ofxCvGrayscaleImage 	cvGrayImage2;
-    ofxCvGrayscaleImage 	cvGrayImage3;
-    ofxCvGrayscaleImage 	cvGrayImage4;
-    
-    ofxCvContourFinder      cvContourFinder1;
-    
-    //this is the temporary container to allow us to convert and save out greyscale images
-    ofxCvColorImage         cvConvertorImage;
     
 };

src/IResponseAnalysis.cpp

@@ -13,6 +13,13 @@ using Poco::Thread;
 #define NUMBER_RUNS     1
 #define ACQUIRE_TIME    20
 
+const int algo_default = 1;
+const int scale_default = 500;
+const int draw_style_default = 3;
+const int line_width_default = 0.5f;
+const float point_size_default = 0.5f;
+
+
 void IResponseAnalysis::setup(int camWidth, int camHeight)
 {
     AbstractAnalysis::setup(camWidth, camHeight);
@@ -47,51 +54,22 @@ void IResponseAnalysis::setup(int camWidth, int camHeight)
     
     image1.clear();
     image2.clear();
-    image3.clear();  
-    image4.clear();
-    image5.clear();
     
     //  images use for drawing the synthesized files to the screen ///
     image1.setUseTexture(false);  // the non texture image that is needed to first load the image
     image2.setUseTexture(true);   // the image that needs to get written to the screen which takes the content of image1
     
-    //  images used for re-loading and saving out the synthesized files ///
-    image3.setUseTexture(false);  
-    image4.setUseTexture(false);
-    image5.setUseTexture(false);
-    
     image1.allocate(RefractiveIndex::_vid_w,RefractiveIndex::_vid_h,  OF_IMAGE_COLOR);
     image2.allocate(RefractiveIndex::_vid_w,RefractiveIndex::_vid_h,  OF_IMAGE_COLOR);
-    image3.allocate(RefractiveIndex::_vid_w,RefractiveIndex::_vid_h,  OF_IMAGE_COLOR);  
-    image4.allocate(RefractiveIndex::_vid_w,RefractiveIndex::_vid_h,  OF_IMAGE_COLOR);
-    image5.allocate(RefractiveIndex::_vid_w,RefractiveIndex::_vid_h,  OF_IMAGE_COLOR);
     
-    //cout << "RefractiveIndex::_vid_w " << RefractiveIndex::_vid_w << endl;
-    //cout << "RefractiveIndex::_vid_h " << RefractiveIndex::_vid_h << endl;
     
-    // clear() apparently fixes the "OF_WARNING: in allocate, reallocating a ofxCvImage" 
+    ////---------
-    // that we're getting in OSX/Windows and is maybe crashing Windows
-    // http://forum.openframeworks.cc/index.php?topic=1867.0
-    cvColorImage1.clear();
-	cvGrayImage1.clear();
-    cvGrayDiff1.clear();
-    
-    cvColorImage2.clear();
-	cvGrayImage2.clear();
-    cvGrayDiff2.clear();
-    
-    cvConvertorImage.clear();    
-    
-    cvColorImage1.allocate(RefractiveIndex::_vid_w,RefractiveIndex::_vid_h);
-	cvGrayImage1.allocate(RefractiveIndex::_vid_w,RefractiveIndex::_vid_h);
-    cvGrayDiff1.allocate(RefractiveIndex::_vid_w,RefractiveIndex::_vid_h);
-    
-    cvColorImage2.allocate(RefractiveIndex::_vid_w,RefractiveIndex::_vid_h);
-	cvGrayImage2.allocate(RefractiveIndex::_vid_w,RefractiveIndex::_vid_h);
-    cvGrayDiff2.allocate(RefractiveIndex::_vid_w,RefractiveIndex::_vid_h);
-    
-    cvConvertorImage.allocate(RefractiveIndex::_vid_w,RefractiveIndex::_vid_h);
     
+    algo = RefractiveIndex::XML.getValue("config:algorithms:iresponse:algo", algo_default);
+    scale = RefractiveIndex::XML.getValue("config:algorithms:iresponse:scale", scale_default);
+    draw_style = RefractiveIndex::XML.getValue("config:algorithms:iresponse:draw_style", draw_style_default);
+    line_width = RefractiveIndex::XML.getValue("config:algorithms:iresponse:line_width", line_width_default);        
+    point_size = RefractiveIndex::XML.getValue("config:algorithms:iresponse:point_size", point_size_default);    
 }
 
 
@@ -126,86 +104,27 @@ void IResponseAnalysis::acquire()
 void IResponseAnalysis::synthesise()
 {
     
-    //cout << "IResponseAnalysis::saving synthesis...\n";
+    // we don't need to synthesise
-    if(_state == STATE_STOP) return;
+    return;
     
-    for(float i=1;i<_saved_filenames_analysis.size()-1;i++){
+    /*
      
-        //cout << "IResponseAnalysis::synthesis FOR LOOP...\n";
+     //cout << "IResponseAnalysis::saving synthesis...\n";
+     if(_state == STATE_STOP) return;
      
-        //cout << "_saved_filenames_analysis[i]" << _saved_filenames_analysis[i] << endl;
+     _RUN_DONE = false;
-        
-        if(_state == STATE_STOP) return;
-        
-        if(!image1.loadImage(_saved_filenames_analysis[i])){
-            //couldn't load image
-            cout << "didn't load image" << endl;
-        } 
-        
-        if(image1.loadImage(_saved_filenames_analysis[i])){
-             //cout << "LOADED image1!!!" << endl;
-            if(image5.loadImage(_saved_filenames_analysis[i+1])){
-                
-                ///////////////////////// PROCESS THE SAVED CAMERA IMAGES OF SHIT TO THE IMAGES //////////////////////////
-                
-                cvColorImage1.setFromPixels(image1.getPixels(), image1.width, image1.height);
-                cvColorImage2.setFromPixels(image5.getPixels(), image5.width, image5.height);
-                
-                cvColorImage1.convertToGrayscalePlanarImage(cvGrayImage1, 1);
-                cvColorImage2.convertToGrayscalePlanarImage(cvGrayImage2, 1);
-                
-                cvGrayDiff1.absDiff(cvGrayImage2, cvGrayImage1);
-                cvGrayDiff1.erode();
-                cvGrayDiff1.contrastStretch();
-                //cvGrayDiff1.blur(5);
-                //cvGrayDiff1.dilate();
-                //cvGrayDiff1.contrastStretch();
-                
-                /////////////////////////////////// SAVE TO DISK IN THE SYNTHESIS FOLDER ////////////////////////////////
-                string file_name;
-                
-                file_name = ofToString(_synth_save_cnt, 2)+"_IResponseSynthesis_"+ofToString(_run_cnt,2)+".jpg";
-                               
-                
-                //<---- THE OLD WAY OF SAVING - works on OSX but generates BLACK FRAMES on WINDOWS ---->
-                // ofSaveImage(cvGrayImage1.getPixelsRef(),_whole_file_path_synthesis+"/"+file_name, OF_IMAGE_QUALITY_BEST);
-                
-                
-                //<---- NEW SAVING - seems to fix WINDOWS saving out BLACK FRAMES PROBLEM ---->
-                //ofImage image;
-                //image.allocate(cvGrayDiff1.width, cvGrayDiff1.height, OF_IMAGE_GRAYSCALE);
-                
-                //*** This needs to be here for OSX of we get a BAD ACCESS ERROR. DOES IT BREAK WINDOWS? ***//
-                //image.setUseTexture(false);  
-                //image.setFromPixels(cvGrayDiff1.getPixels(), cvGrayDiff1.width, cvGrayDiff1.height, OF_IMAGE_GRAYSCALE);
-                //image.saveImage(_whole_file_path_synthesis+"/"+file_name);
-                //_saved_filenames_synthesis.push_back(_whole_file_path_synthesis+"/"+file_name);
-                
-                
-                // <--- REALLY NEW SAVING METHOD --- 26 feb 2012 --- consolidated the save function into Abstract Analysis> ///
-                cvConvertorImage.setFromGrayscalePlanarImages(cvGrayDiff1,cvGrayDiff1,cvGrayDiff1);
-                
-                saveImageSynthesis(file_name, &cvConvertorImage, OF_IMAGE_GRAYSCALE);
-                
-                _synth_save_cnt++;
-                
-        
-
-            }
-        }
-    }
-
-    // _saved_filenames_synthesis has processed all the files in the analysis images folder
-    while(!_RUN_DONE && _state != STATE_STOP)
-        Thread::sleep(3);
      
+     // _saved_filenames_synthesis has processed all the files in the analysis images folder
+     while(!_RUN_DONE && _state != STATE_STOP)
+     Thread::sleep(3);
+     */    
     
 }
 
 
 void IResponseAnalysis::displayresults()
 {
-    for(float i=1;i<_saved_filenames_synthesis.size();i++){
+    for(float i=1;i<_saved_filenames_analysis.size();i++){
         
         if(_state == STATE_STOP) return;
         
@@ -216,13 +135,15 @@ void IResponseAnalysis::displayresults()
             //cout << "!_image_shown" << endl;
         }
         
-        if(!image3.loadImage(_saved_filenames_synthesis[i])){
+        _show_image = false;
+        
+        
+        if(!image1.loadImage(_saved_filenames_analysis[i])){
             //couldn't load image
-            // cout << "didn't load image" << endl;
+            cout << "didn't load image" << endl;
         } 
         
-        if(image3.loadImage(_saved_filenames_synthesis[i])){
+        if(image1.loadImage(_saved_filenames_analysis[i])){
-            image3.loadImage(_saved_filenames_synthesis[i]);
             //cout << "_show_image = true;" << endl;
             _show_image = true;
             _image_shown = false;
@@ -363,8 +284,6 @@ void IResponseAnalysis::draw()
             
         case STATE_DISPLAY_RESULTS:
         {
-            //cout << "STATE_DISPLAY_RESULTS...\n" << endl;
-            
             if (_frame_cnt > 2)
             {
                 _image_shown = true;
@@ -373,21 +292,47 @@ void IResponseAnalysis::draw()
             
             _frame_cnt++;
             
+            ofEnableAlphaBlending();
+            glShadeModel(GL_SMOOTH);
+            glLineWidth(line_width);
+            glPointSize(point_size);
+            glEnable(GL_POINT_SMOOTH);
+            
+            //RefractiveIndex::cam.begin();
+            
+            ofTranslate(tx, ty, tz);
+            ofRotateX(rx); ofRotateY(ry); ofRotateZ(rz);
+            glScalef(1.5, 1, 1);
+            
             if (_show_image)
-            {  
+                image2.setFromPixels(image1.getPixels(), image1.width, image1.height, OF_IMAGE_COLOR);
-                //cout << "_show_image...\n" << endl;
             
-                ofEnableAlphaBlending();
+            image2.bind();        
             
-                ofSetColor(255, 255, 255);
+            RefractiveIndex::_shader.begin();
-                image2.setFromPixels(image3.getPixels(),image3.width,image3.height, OF_IMAGE_COLOR);
-                image2.draw(0,0, ofGetWidth(), ofGetHeight());
             
-                ofDisableAlphaBlending();
+            RefractiveIndex::_shader.setUniform1i("algo", algo);
+            RefractiveIndex::_shader.setUniform1f("scale", scale);
+            RefractiveIndex::_shader.setUniform1i("tex0", 0);
+            
+            switch (draw_style) {
+                case VERTS:
+                    RefractiveIndex::_mesh_vbo.drawVertices();
+                    break;
+                case WIRE:
+                    RefractiveIndex::_mesh_vbo.drawWireframe();
+                    break;
+                case FACE:
+                    RefractiveIndex::_mesh_vbo.drawFaces();
+                    break;            
             }
             
-            // display results of the synthesis
+            RefractiveIndex::_shader.end();                
-            _RUN_DONE = true;
+            
+            image2.unbind();
+            
+            //RefractiveIndex::cam.end();    
+            
             break;
             
         }

src/IResponseAnalysis.h

@@ -35,31 +35,14 @@ protected:
     float   c, _frame_cnt, _frame_cnt_max, _anim_cnt_max;
   
     bool _show_image, _image_shown;
+    
     ofImage         image1;
     ofImage         image2; 
-    ofImage         image3;
-    ofImage         image4;
-    ofImage         image5; 
-    ofImage         image6; 
     
-    ofxCvColorImage         cvColorImage1;
+    int algo;
-    ofxCvColorImage         cvColorImage2;
+    int scale;
-    ofxCvColorImage         cvColorImage3;
+    int draw_style;   
-    ofxCvColorImage         cvColorImage4;
+    float line_width;
-    ofxCvColorImage         cvColorImage5;
+    float point_size;
-    ofxCvColorImage         cvColorImage6;
-    
-    ofxCvGrayscaleImage 	cvGrayDiff1;
-    ofxCvGrayscaleImage 	cvGrayDiff2;
-    
-    ofxCvGrayscaleImage 	cvGrayImage1;
-    ofxCvGrayscaleImage 	cvGrayImage2;
-    ofxCvGrayscaleImage 	cvGrayImage3;
-    ofxCvGrayscaleImage 	cvGrayImage4;
-    
-    ofxCvContourFinder      cvContourFinder1;
-    
-    //this is the temporary container to allow us to convert and save out greyscale images
-    ofxCvColorImage         cvConvertorImage;
     
 };

src/RelaxRateAnalysis.cpp

@@ -12,8 +12,12 @@ using Poco::Thread;
 
 #define NUMBER_RUNS     1
 #define ACQUIRE_TIME    20
-#define TRESHOLD        80
+
-#define MAXBLOBS        15
+const int algo_default = 1;
+const int scale_default = 500;
+const int draw_style_default = 3;
+const int line_width_default = 0.5f;
+const float point_size_default = 0.5f;
 
 void RelaxRateAnalysis::setup(int camWidth, int camHeight)
 {
@@ -27,15 +31,6 @@ void RelaxRateAnalysis::setup(int camWidth, int camHeight)
     acq_run_time = RefractiveIndex::XML.getValue("config:analysis_time:acquiretime_relaxrate", ACQUIRE_TIME);
     cout << "ACQUIRE_TIME RelaxRateAnalysis " << acq_run_time << endl;
     
-    _treshold = RefractiveIndex::XML.getValue("config:relaxrate:treshold", TRESHOLD);
-    cout << "TRESHOLD RelaxRateAnalysis " << _treshold << endl;
-    
-    _maxblobs = RefractiveIndex::XML.getValue("config:relaxrate:maxblobs", MAXBLOBS);
-    cout << "MAXBLOBS RelaxRateAnalysis " << _maxblobs << endl;
-
-    
-    //int acq_run_time = 20;   // 20 seconds of acquiring per run
-    
     DELTA_T_SAVE = 2*(10*acq_run_time/2); // for 20 seconds, we want this to be around 200 files
     // or 10 times per second = every 100 ms
     
@@ -57,17 +52,23 @@ void RelaxRateAnalysis::setup(int camWidth, int camHeight)
     _image_shown = false;
     
     image1.clear();
+    image2.clear();
+    
+    //  images use for drawing the synthesized files to the screen ///
     image1.setUseTexture(false);  // the non texture image that is needed to first load the image
+    image2.setUseTexture(true);   // the image that needs to get written to the screen which takes the content of image1
+    
     image1.allocate(RefractiveIndex::_vid_w,RefractiveIndex::_vid_h,  OF_IMAGE_COLOR);
+    image2.allocate(RefractiveIndex::_vid_w,RefractiveIndex::_vid_h,  OF_IMAGE_COLOR);
     
-    // clear() apparently fixes the "OF_WARNING: in allocate, reallocating a ofxCvImage" 
-    // that we're getting in OSX/Windows and is maybe crashing Windows
-    // http://forum.openframeworks.cc/index.php?topic=1867.0
-    cvColorImage1.clear();
-    cvGrayDiff1.clear();
     
-    cvColorImage1.allocate(RefractiveIndex::_vid_w,RefractiveIndex::_vid_h);
+    ////---------
-    cvGrayDiff1.allocate(RefractiveIndex::_vid_w,RefractiveIndex::_vid_h);
+    
+    algo = RefractiveIndex::XML.getValue("config:algorithms:relaxrate:algo", algo_default);
+    scale = RefractiveIndex::XML.getValue("config:algorithms:relaxrate:scale", scale_default);
+    draw_style = RefractiveIndex::XML.getValue("config:algorithms:relaxrate:draw_style", draw_style_default);
+    line_width = RefractiveIndex::XML.getValue("config:algorithms:relaxrate:line_width", line_width_default);        
+    point_size = RefractiveIndex::XML.getValue("config:algorithms:relaxrate:point_size", point_size_default);
     
 }
 
@@ -101,77 +102,53 @@ void RelaxRateAnalysis::acquire()
 
 void RelaxRateAnalysis::synthesise()
 {
+    // we don't need to synthesise
+    return;
+    
+    /*
+    
     //cout << "IResponseAnalysis::saving synthesis...\n";
     if(_state == STATE_STOP) return;
     
-    cvContourFinderVect.clear();    
+    _RUN_DONE = false;
-    
-    
-    for(float i=1;i<_saved_filenames_analysis.size();i++){
-                
-        if(_state == STATE_STOP) return;
-                
-        if(image1.loadImage(_saved_filenames_analysis[i])){
-                
-            ///////////////////////// PROCESS THE SAVED CAMERA IMAGES OF SHIT TO THE IMAGES //////////////////////////
-            
-            cvColorImage1.setFromPixels(image1.getPixels(), image1.width, image1.height);            
-            cvColorImage1.convertToGrayscalePlanarImage(cvGrayDiff1, 1);
-            
-            cvGrayDiff1.threshold(_treshold);
-            
-            rfiCvContourFinder* cf = new rfiCvContourFinder();
-            
-            cf->findContours(cvGrayDiff1, 20, (image1.width * image1.height) / 4, _maxblobs, true);
-            
-            cvContourFinderVect.push_back(cf);
-            
-        }
-    }
     
     // _saved_filenames_synthesis has processed all the files in the analysis images folder
     while(!_RUN_DONE && _state != STATE_STOP)
         Thread::sleep(3);
+     */
+
     
 }
 
 void RelaxRateAnalysis::displayresults()
 {
         
-    //cvContourFinderVectDisplay.clear();
+    for(float i=1;i<_saved_filenames_analysis.size();i++){
-    clearcfindervectdisplay();
-    
-    for(int i=1;i<cvContourFinderVect.size();i++){
-        
-        if(_state == STATE_STOP){
-            clearcfindervectdisplay();
-            clearcfindervect();
-            return;
-        }        
         
+        if(_state == STATE_STOP) return;
         
         //cout << "_saved_filenames_analysis[i] - " << _saved_filenames_synthesis[i] << endl;
         
         while(!_image_shown){
             Thread::sleep(2);
-            if(_state == STATE_STOP) return;
             //cout << "!_image_shown" << endl;
         }
         
-        cvContourFinderVectDisplay.push_back(cvContourFinderVect[i]);    
+        _show_image = false;
-        _show_image = true;
-        _image_shown = false;
         
+        
+        if(!image1.loadImage(_saved_filenames_analysis[i])){
+            //couldn't load image
+            cout << "didn't load image" << endl;
+        } 
+        
+        if(image1.loadImage(_saved_filenames_analysis[i])){
+            //cout << "_show_image = true;" << endl;
+            _show_image = true;
+            _image_shown = false;
+        }
     }        
     
-    clearcfindervectdisplay();
-    clearcfindervect();
-    
-        
-    //cvContourFinderVectDisplay.clear();
-    //cvContourFinderVect.clear();
-    
-    
 }
 
 
@@ -312,16 +289,47 @@ void RelaxRateAnalysis::draw()
             
             _frame_cnt++;
                         
-            if (_show_image)
+            ofEnableAlphaBlending();
-            {  
+            glShadeModel(GL_SMOOTH);
-                for(int i=0;i<cvContourFinderVectDisplay.size();i++){
+            glLineWidth(line_width);
-                    cvContourFinderVectDisplay[i]->draw(0,0, ofGetWidth(), ofGetHeight());
+            glPointSize(point_size);
-                }
+            glEnable(GL_POINT_SMOOTH);
             
+            //RefractiveIndex::cam.begin();
+            
+            ofTranslate(tx, ty, tz);
+            ofRotateX(rx); ofRotateY(ry); ofRotateZ(rz);
+            glScalef(1.5, 1, 1);
+            
+            if (_show_image)
+                image2.setFromPixels(image1.getPixels(), image1.width, image1.height, OF_IMAGE_COLOR);
+            
+            image2.bind();        
+            
+            RefractiveIndex::_shader.begin();
+            
+            RefractiveIndex::_shader.setUniform1i("algo", algo);
+            RefractiveIndex::_shader.setUniform1f("scale", scale);
+            RefractiveIndex::_shader.setUniform1i("tex0", 0);
+            
+            switch (draw_style) {
+                case VERTS:
+                    RefractiveIndex::_mesh_vbo.drawVertices();
+                    break;
+                case WIRE:
+                    RefractiveIndex::_mesh_vbo.drawWireframe();
+                    break;
+                case FACE:
+                    RefractiveIndex::_mesh_vbo.drawFaces();
+                    break;            
             }
             
-            // display results of the synthesis
+            RefractiveIndex::_shader.end();                
-            _RUN_DONE = true;
+            
+            image2.unbind();
+            
+            //RefractiveIndex::cam.end();    
+            
             break;
         
         }
@@ -340,31 +348,5 @@ void RelaxRateAnalysis::save_cb(Timer& timer)
     string file_name = ofToString(_save_cnt,2)+"_"+ ofToString(c,2)+"_"+ofToString(_run_cnt,2)+".jpg";
     
     saveImageAnalysis(file_name);        
-    
-    
-}
-
-void RelaxRateAnalysis::cleanup()
-{
-}
-
-
-void RelaxRateAnalysis::clearcfindervect()
-{
-    for(int i = 0; i < cvContourFinderVect.size(); i++) {
-        rfiCvContourFinder* f = cvContourFinderVect[i];
-
-        // maybe it's erase here?  http://forum.openframeworks.cc/index.php/topic,3016.0.html
-        // cvContourFinderVect.erase(i);
-        
-        delete f;        
-    }
-    cvContourFinderVect.clear();
-    
-}
-
-void RelaxRateAnalysis::clearcfindervectdisplay()
-{
-    cvContourFinderVectDisplay.clear();
 }
 

src/RelaxRateAnalysis.h

@@ -23,7 +23,6 @@ public:
     void acquire();
     void synthesise(); 
     void displayresults();
-    void cleanup();
 
     void draw();
     
@@ -31,8 +30,6 @@ public:
     
 protected:
     
-    void clearcfindervect();
-    void clearcfindervectdisplay();
     
     bool    _RUN_DONE;
     float     _flip, _level;
@@ -44,11 +41,13 @@ protected:
     
     bool _show_image, _image_shown;
     
-    ofImage                 image1;    
+    ofImage         image1;
-    ofxCvColorImage         cvColorImage1;    
+    ofImage         image2; 
-    ofxCvGrayscaleImage 	cvGrayDiff1;
     
-    vector<rfiCvContourFinder*>      cvContourFinderVect;
+    int algo;
-    vector<rfiCvContourFinder*>      cvContourFinderVectDisplay;
+    int scale;
+    int draw_style;   
+    float line_width;
+    float point_size;
 
 };

src/ShadowScapesAnalysis.cpp

@@ -17,6 +17,11 @@ using Poco::Thread;
 #define NUMBER_RUNS     1
 #define ACQUIRE_TIME    20
 
+const int algo_default = 1;
+const int scale_default = 500;
+const int draw_style_default = 3;
+const double line_width_default = 0.5;
+
 void ShadowScapesAnalysis::setup(int camWidth, int camHeight)
 {
     AbstractAnalysis::setup(camWidth, camHeight);
@@ -42,7 +47,7 @@ void ShadowScapesAnalysis::setup(int camWidth, int camHeight)
     DELTA_T_SAVE = 3*(10*acq_run_time/2);   // for 20 seconds, we want this to be around 100 files
                                             // or 5 times per second = every 200 ms
     
-    _scanLineWidth = 100.0;
+    _scanLineWidth = 300.0;
     _run_cnt = 0;
     _save_cnt = 0;
     _synth_save_cnt = 0;
@@ -55,50 +60,21 @@ void ShadowScapesAnalysis::setup(int camWidth, int camHeight)
     
     image1.clear();
     image2.clear();
-    image3.clear();  
-    image4.clear();
-    image5.clear();
     
     //  images use for drawing the synthesized files to the screen ///
     image1.setUseTexture(false);  // the non texture image that is needed to first load the image
     image2.setUseTexture(true);   // the image that needs to get written to the screen which takes the content of image1
     
-    //  images used for re-loading and saving out the synthesized files ///
-    image3.setUseTexture(false);  
-    image4.setUseTexture(false);
-    image5.setUseTexture(false);
-    
     image1.allocate(RefractiveIndex::_vid_w,RefractiveIndex::_vid_h,  OF_IMAGE_COLOR);
     image2.allocate(RefractiveIndex::_vid_w,RefractiveIndex::_vid_h,  OF_IMAGE_COLOR);
-    image3.allocate(RefractiveIndex::_vid_w,RefractiveIndex::_vid_h,  OF_IMAGE_COLOR);  
-    image4.allocate(RefractiveIndex::_vid_w,RefractiveIndex::_vid_h,  OF_IMAGE_COLOR);
-    image5.allocate(RefractiveIndex::_vid_w,RefractiveIndex::_vid_h,  OF_IMAGE_COLOR);
     
-    //cout << "RefractiveIndex::_vid_w " << RefractiveIndex::_vid_w << endl;
-    //cout << "RefractiveIndex::_vid_h " << RefractiveIndex::_vid_h << endl;
     
-    // clear() apparently fixes the "OF_WARNING: in allocate, reallocating a ofxCvImage" 
+    ////---------
-    // that we're getting in OSX/Windows and is maybe crashing Windows
-    // http://forum.openframeworks.cc/index.php?topic=1867.0
-    cvColorImage1.clear();
-	cvGrayImage1.clear();
-    cvGrayDiff1.clear();
     
-    cvColorImage2.clear();
+    algo = RefractiveIndex::XML.getValue("config:algorithms:shadowscapes:algo", algo_default);
-	cvGrayImage2.clear();
+    scale = RefractiveIndex::XML.getValue("config:algorithms:shadowscapes:scale", scale_default);
-    cvGrayDiff2.clear();
+    draw_style = RefractiveIndex::XML.getValue("config:algorithms:shadowscapes:draw_style", draw_style_default);
-    
+    line_width = RefractiveIndex::XML.getValue("config:algorithms:shadowscapes:line_width", line_width_default);
-    cvConvertorImage.clear();    
-    
-    cvColorImage1.allocate(RefractiveIndex::_vid_w,RefractiveIndex::_vid_h);
-	cvGrayImage1.allocate(RefractiveIndex::_vid_w,RefractiveIndex::_vid_h);
-    cvGrayDiff1.allocate(RefractiveIndex::_vid_w,RefractiveIndex::_vid_h);
-    
-    cvColorImage2.allocate(RefractiveIndex::_vid_w,RefractiveIndex::_vid_h);
-	cvGrayImage2.allocate(RefractiveIndex::_vid_w,RefractiveIndex::_vid_h);
-    cvGrayDiff2.allocate(RefractiveIndex::_vid_w,RefractiveIndex::_vid_h);
-    
-    cvConvertorImage.allocate(RefractiveIndex::_vid_w,RefractiveIndex::_vid_h);
     
 }
 
@@ -126,116 +102,50 @@ void ShadowScapesAnalysis::acquire()
 
 void ShadowScapesAnalysis::synthesise()
 {
-    //cout << "ShadowScapesAnalysis::saving synthesis...\n";
+    // we don't need to synthesise
+    return;
     
-    for(float i=1;i<_saved_filenames_analysis.size()-1; i++){
+    /*
      
-      //  cout << "ShadowScapesAnalysis::synthesis FOR LOOP...\n";
+     //cout << "IResponseAnalysis::saving synthesis...\n";
+     if(_state == STATE_STOP) return;
      
-        // cout << "_saved_filenames_analysis[i]" << _saved_filenames_analysis[i] << endl;
+     _RUN_DONE = false;
+     
+     // _saved_filenames_synthesis has processed all the files in the analysis images folder
+     while(!_RUN_DONE && _state != STATE_STOP)
+     Thread::sleep(3);
+     */
+}
+
+
+void ShadowScapesAnalysis::displayresults()
+{
+    for(float i=1;i<_saved_filenames_analysis.size();i++){
         
         if(_state == STATE_STOP) return;
         
+        //cout << "_saved_filenames_analysis[i] - " << _saved_filenames_synthesis[i] << endl;
+        
+        while(!_image_shown){
+            Thread::sleep(2);
+            //cout << "!_image_shown" << endl;
+        }
+        
+        _show_image = false;
+        
+        
         if(!image1.loadImage(_saved_filenames_analysis[i])){
             //couldn't load image
             cout << "didn't load image" << endl;
         } 
         
         if(image1.loadImage(_saved_filenames_analysis[i])){
-            
-            if(image5.loadImage(_saved_filenames_analysis[i+1])){
-                
-                ///////////////////////// PROCESS THE SAVED CAMERA IMAGES OF SHIT TO THE IMAGES //////////////////////////
-                               
-                cvColorImage1.setFromPixels(image1.getPixels(), image1.width, image1.height);
-                cvColorImage2.setFromPixels(image5.getPixels(), image5.width, image5.height);
-                
-                //cvGrayImage1 = cvColorImage1;
-                //cvGrayImage2 = cvColorImage2;
-                
-                cvColorImage1.convertToGrayscalePlanarImage(cvGrayImage1, 1);
-                cvColorImage2.convertToGrayscalePlanarImage(cvGrayImage2, 1);
-      
-                cvGrayDiff1.absDiff(cvGrayImage2, cvGrayImage1);
-                cvGrayDiff1.erode();
-                cvGrayDiff1.contrastStretch();
-                cvGrayDiff1.blur(5);
-                cvGrayDiff1.dilate();
-                
-                /////////////////////////////////// SAVE TO DISK IN THE SYNTHESIS FOLDER ////////////////////////////////
-                string file_name;
-                
-                if(_dir == H) {
-                    file_name = ofToString(_synth_save_cnt, 2)+"_H_ShadowScapesSynthesis_"+ofToString(_run_cnt,2)+".jpg";
-                }
-                
-                if(_dir == V) {
-                    file_name = ofToString(_synth_save_cnt, 2)+"_V_ShadowScapesSynthesis_"+ofToString(_run_cnt,2)+".jpg";
-                }    
-                
-                if(_dir == D) {
-                    file_name = ofToString(_synth_save_cnt, 2)+"_D_ShadowScapesSynthesis_"+ofToString(_run_cnt,2)+".jpg";
-                }
-                
-                
-                
-                //<---- THE OLD WAY OF SAVING - works on OSX but generates BLACK FRAMES on WINDOWS ---->
-                // ofSaveImage(cvGrayImage1.getPixelsRef(),_whole_file_path_synthesis+"/"+file_name, OF_IMAGE_QUALITY_BEST);
-                
-                
-                //<---- NEW SAVING - seems to fix WINDOWS saving out BLACK FRAMES PROBLEM ---->
-                //ofImage image;
-                //image.allocate(cvGrayDiff1.width, cvGrayDiff1.height, OF_IMAGE_GRAYSCALE);
-                
-                //*** This needs to be here for OSX of we get a BAD ACCESS ERROR. DOES IT BREAK WINDOWS? ***//
-                //image.setUseTexture(false);  
-                
-                //image.setFromPixels(cvGrayDiff1.getPixels(), cvGrayDiff1.width, cvGrayDiff1.height, OF_IMAGE_GRAYSCALE);
-                //image.saveImage(_whole_file_path_synthesis+"/"+file_name);
-
-                //_saved_filenames_synthesis.push_back(_whole_file_path_synthesis+"/"+file_name);
-                               
-                // <--- REALLY NEW SAVING METHOD --- 26 feb 2012 --- consolidated the save function into Abstract Analysis> ///
-                cvConvertorImage.setFromGrayscalePlanarImages(cvGrayDiff1,cvGrayDiff1,cvGrayDiff1);
-                
-                saveImageSynthesis(file_name, &cvConvertorImage, OF_IMAGE_GRAYSCALE);
-                _synth_save_cnt++;
-            }
-        }
-    }
-    
-    // _saved_filenames_synthesis has processed all the files in the analysis images folder
-     while(!_RUN_DONE && _state != STATE_STOP)
-        Thread::sleep(3);
-}
-
-
-void ShadowScapesAnalysis::displayresults()
-{
-    for(float i=1;i<_saved_filenames_synthesis.size();i++){
-        
-        if(_state == STATE_STOP) return;
-        
-       // cout << "_saved_filenames_analysis[i] - " << _saved_filenames_synthesis[i] << endl;
-        
-        while(!_image_shown){
-            Thread::sleep(2);
-            //cout << "!_image_shown" << endl;
-        }
-        
-        if(!image3.loadImage(_saved_filenames_synthesis[i])){
-            //couldn't load image
-            cout << "didn't load image" << endl;
-        } 
-        
-        if(image3.loadImage(_saved_filenames_synthesis[i])){
-            image3.loadImage(_saved_filenames_synthesis[i]);
             //cout << "_show_image = true;" << endl;
             _show_image = true;
             _image_shown = false;
         }
     }    
-
 }
 
 
@@ -423,27 +333,47 @@ void ShadowScapesAnalysis::draw()
             
             _frame_cnt++;
             
+            
+            ofEnableAlphaBlending();
+            glShadeModel(GL_SMOOTH);
+            glLineWidth(line_width);
+            
+            //RefractiveIndex::cam.begin();
+            
+            ofTranslate(tx, ty, tz);
+            ofRotateX(rx); ofRotateY(ry); ofRotateZ(rz);
+            glScalef(1.5, 1, 1);
+            
             if (_show_image)
-            {  
+                image2.setFromPixels(image1.getPixels(), image1.width, image1.height, OF_IMAGE_COLOR);
-              //  cout << "_show_image...\n" << endl;
             
-                ofEnableAlphaBlending();
+            image2.bind();        
             
-                    ofSetColor(255, 255, 255);
+            RefractiveIndex::_shader.begin();
-                
-                    image2.setFromPixels(image3.getPixels(),image3.width,image3.height, OF_IMAGE_COLOR);
-                    image2.draw(0,0, ofGetWidth(), ofGetHeight());
-                
-                ofDisableAlphaBlending();
             
+            RefractiveIndex::_shader.setUniform1i("algo", algo);
+            RefractiveIndex::_shader.setUniform1f("scale", scale);
+            RefractiveIndex::_shader.setUniform1i("tex0", 0);
             
+            switch (draw_style) {
+                case VERTS:
+                    RefractiveIndex::_mesh_vbo.drawVertices();
+                    break;
+                case WIRE:
+                    RefractiveIndex::_mesh_vbo.drawWireframe();
+                    break;
+                case FACE:
+                    RefractiveIndex::_mesh_vbo.drawFaces();
+                    break;            
             }
             
-            // display results of the synthesis
+            RefractiveIndex::_shader.end();                
+            
+            image2.unbind();
+            
+            //RefractiveIndex::cam.end();    
+            
             _RUN_DONE = true;
-            
-            // clear allocated memory...? 
-            
             break;
         }
             

src/ShadowScapesAnalysis.h

@@ -42,31 +42,13 @@ protected:
     float   c, _frame_cnt, _frame_cnt_max, _anim_cnt_max;
     
     bool _show_image, _image_shown;
+        
     ofImage         image1;
     ofImage         image2; 
-    ofImage         image3;
-    ofImage         image4;
-    ofImage         image5; 
-    ofImage         image6; 
     
-    ofxCvColorImage         cvColorImage1;
+    int algo;
-    ofxCvColorImage         cvColorImage2;
+    int scale;
-    ofxCvColorImage         cvColorImage3;
+    int draw_style;    
-    ofxCvColorImage         cvColorImage4;
+    double line_width;
-    ofxCvColorImage         cvColorImage5;
-    ofxCvColorImage         cvColorImage6;
-    
-    ofxCvGrayscaleImage 	cvGrayDiff1;
-    ofxCvGrayscaleImage 	cvGrayDiff2;
-    
-    ofxCvGrayscaleImage 	cvGrayImage1;
-    ofxCvGrayscaleImage 	cvGrayImage2;
-    ofxCvGrayscaleImage 	cvGrayImage3;
-    ofxCvGrayscaleImage 	cvGrayImage4;
-    
-    ofxCvContourFinder      cvContourFinder1;
-    
-    //this is the temporary container to allow us to convert and save out greyscale images
-    ofxCvColorImage         cvConvertorImage;    
 
 };

src/ShapeFromShadingAnalysis.cpp

@@ -13,6 +13,13 @@ using Poco::Thread;
 #define NUMBER_RUNS     1
 #define ACQUIRE_TIME    20
 
+const int algo_default = 1;
+const int scale_default = 500;
+const int draw_style_default = 3;
+const int line_width_default = 0.5f;
+const float point_size_default = 0.5f;
+
+
 void ShapeFromShadingAnalysis::setup(int camWidth, int camHeight)
 {       
     AbstractAnalysis::setup(camWidth, camHeight);
@@ -47,50 +54,21 @@ void ShapeFromShadingAnalysis::setup(int camWidth, int camHeight)
     
     image1.clear();
     image2.clear();
-    image3.clear();  
-    image4.clear();
-    image5.clear();
     
-    //  images use for drawing the synthesized files to the screen ///
+    image1.setUseTexture(false);  
-    image1.setUseTexture(false);  // the non texture image that is needed to first load the image
+    image2.setUseTexture(true);  
-    image2.setUseTexture(true);   // the image that needs to get written to the screen which takes the content of image1
-    
-    //  images used for re-loading and saving out the synthesized files ///
-    image3.setUseTexture(false);  
-    image4.setUseTexture(false);
-    image5.setUseTexture(false);
     
     image1.allocate(RefractiveIndex::_vid_w,RefractiveIndex::_vid_h,  OF_IMAGE_COLOR);
     image2.allocate(RefractiveIndex::_vid_w,RefractiveIndex::_vid_h,  OF_IMAGE_COLOR);
-    image3.allocate(RefractiveIndex::_vid_w,RefractiveIndex::_vid_h,  OF_IMAGE_COLOR);  
-    image4.allocate(RefractiveIndex::_vid_w,RefractiveIndex::_vid_h,  OF_IMAGE_COLOR);
-    image5.allocate(RefractiveIndex::_vid_w,RefractiveIndex::_vid_h,  OF_IMAGE_COLOR);
     
-   // cout << "RefractiveIndex::_vid_w " << RefractiveIndex::_vid_w << endl;
+    ////---------
-   // cout << "RefractiveIndex::_vid_h " << RefractiveIndex::_vid_h << endl;
     
-    // clear() apparently fixes the "OF_WARNING: in allocate, reallocating a ofxCvImage" 
+    algo = RefractiveIndex::XML.getValue("config:algorithms:shapeshade:algo", algo_default);
-    // that we're getting in OSX/Windows and is maybe crashing Windows
+    scale = RefractiveIndex::XML.getValue("config:algorithms:shapeshade:scale", scale_default);
-    // http://forum.openframeworks.cc/index.php?topic=1867.0
+    draw_style = RefractiveIndex::XML.getValue("config:algorithms:shapeshade:draw_style", draw_style_default);
-    cvColorImage1.clear();
+    line_width = RefractiveIndex::XML.getValue("config:algorithms:shapeshade:line_width", line_width_default);        
-	cvGrayImage1.clear();
+    point_size = RefractiveIndex::XML.getValue("config:algorithms:shapeshade:point_size", point_size_default);
-    cvGrayDiff1.clear();
 
-    cvColorImage2.clear();
-	cvGrayImage2.clear();
-    cvGrayDiff2.clear();
-    
-    cvConvertorImage.clear();    
-    
-    cvColorImage1.allocate(RefractiveIndex::_vid_w,RefractiveIndex::_vid_h);
-	cvGrayImage1.allocate(RefractiveIndex::_vid_w,RefractiveIndex::_vid_h);
-    cvGrayDiff1.allocate(RefractiveIndex::_vid_w,RefractiveIndex::_vid_h);
-    
-    cvColorImage2.allocate(RefractiveIndex::_vid_w,RefractiveIndex::_vid_h);
-	cvGrayImage2.allocate(RefractiveIndex::_vid_w,RefractiveIndex::_vid_h);
-    cvGrayDiff2.allocate(RefractiveIndex::_vid_w,RefractiveIndex::_vid_h);
-    
-    cvConvertorImage.allocate(RefractiveIndex::_vid_w,RefractiveIndex::_vid_h);
 
 }
 
@@ -146,99 +124,46 @@ void ShapeFromShadingAnalysis::acquire()
 
 void ShapeFromShadingAnalysis::synthesise()
 {
-   // cout << "ShapeFromShadingAnalysis::saving synthesis...\n";
+    // we don't need to synthesise
-    if(_state == STATE_STOP) return;
+    return;
     
-    for(float i=1;i<_saved_filenames_analysis.size()-1;i++){
+    /*
      
-    //    cout << "ShapeFromShadingAnalysis::synthesis FOR LOOP...\n";
+     //cout << "IResponseAnalysis::saving synthesis...\n";
+     if(_state == STATE_STOP) return;
      
-     //   cout << "_saved_filenames_analysis[i]" << _saved_filenames_analysis[i] << endl;
+     _RUN_DONE = false;
+     
+     // _saved_filenames_synthesis has processed all the files in the analysis images folder
+     while(!_RUN_DONE && _state != STATE_STOP)
+     Thread::sleep(3);
+     */
+
+    
+}
+
+void ShapeFromShadingAnalysis::displayresults()
+{
+    for(float i=1;i<_saved_filenames_analysis.size();i++){
         
         if(_state == STATE_STOP) return;
         
+        //cout << "_saved_filenames_analysis[i] - " << _saved_filenames_synthesis[i] << endl;
+        
+        while(!_image_shown){
+            Thread::sleep(2);
+            //cout << "!_image_shown" << endl;
+        }
+        
+        _show_image = false;
+        
+        
         if(!image1.loadImage(_saved_filenames_analysis[i])){
             //couldn't load image
             cout << "didn't load image" << endl;
         } 
         
         if(image1.loadImage(_saved_filenames_analysis[i])){
-        //    cout << "LOADED image1!!!" << endl;
-            if(image5.loadImage(_saved_filenames_analysis[i+1])){
-                
-                ///////////////////////// PROCESS THE SAVED CAMERA IMAGES OF SHIT TO THE IMAGES //////////////////////////
-                
-                cvColorImage1.setFromPixels(image1.getPixels(), image1.width, image1.height);
-                cvColorImage2.setFromPixels(image5.getPixels(), image5.width, image5.height);
-                
-                cvColorImage1.convertToGrayscalePlanarImage(cvGrayImage1, 1);
-                cvColorImage2.convertToGrayscalePlanarImage(cvGrayImage2, 1);
-                
-                cvGrayDiff1.absDiff(cvGrayImage2, cvGrayImage1);
-                cvGrayDiff1.erode();
-                cvGrayDiff1.contrastStretch();
-                //cvGrayDiff1.blur(5);
-                //cvGrayDiff1.dilate();
-                //cvGrayDiff1.contrastStretch();
-                
-                /////////////////////////////////// SAVE TO DISK IN THE SYNTHESIS FOLDER ////////////////////////////////
-                string file_name;
-                
-                file_name = ofToString(_synth_save_cnt, 2)+"_ShapeFromShadingSynthesis_"+ofToString(_run_cnt,2)+".jpg";
-                
-                
-                //<---- THE OLD WAY OF SAVING - works on OSX but generates BLACK FRAMES on WINDOWS ---->
-                // ofSaveImage(cvGrayImage1.getPixelsRef(),_whole_file_path_synthesis+"/"+file_name, OF_IMAGE_QUALITY_BEST);
-            
-                //<---- NEW SAVING - seems to fix WINDOWS saving out BLACK FRAMES PROBLEM ---->
-                //ofImage image;
-                //image.allocate(cvGrayDiff1.width, cvGrayDiff1.height, OF_IMAGE_GRAYSCALE);
-                
-                //*** This needs to be here for OSX of we get a BAD ACCESS ERROR. DOES IT BREAK WINDOWS? ***//
-                //image.setUseTexture(false);  
-               
-                //image.setFromPixels(cvGrayDiff1.getPixels(), cvGrayDiff1.width, cvGrayDiff1.height, OF_IMAGE_GRAYSCALE);
-                //image.saveImage(_whole_file_path_synthesis+"/"+file_name);
-                
-                //_saved_filenames_synthesis.push_back(_whole_file_path_synthesis+"/"+file_name);
-                
-                
-                // <--- REALLY NEW SAVING METHOD --- 26 feb 2012 --- consolidated the save function into Abstract Analysis> ///
-                cvConvertorImage.setFromGrayscalePlanarImages(cvGrayDiff1,cvGrayDiff1,cvGrayDiff1);
-                
-                saveImageSynthesis(file_name, &cvConvertorImage, OF_IMAGE_GRAYSCALE);
-                _synth_save_cnt++;
-                
-            }
-        }
-    }
-    
-    // _saved_filenames_synthesis has processed all the files in the analysis images folder
-    while(!_RUN_DONE && _state != STATE_STOP)
-        Thread::sleep(3);    
-    
-}
-
-void ShapeFromShadingAnalysis::displayresults()
-{
-    for(float i=1;i<_saved_filenames_synthesis.size();i++){
-        
-        if(_state == STATE_STOP) return;
-        
-       // cout << "_saved_filenames_analysis[i] - " << _saved_filenames_synthesis[i] << endl;
-        
-        while(!_image_shown){
-            Thread::sleep(2);
-            //cout << "!_image_shown" << endl;
-        }
-        
-        if(!image3.loadImage(_saved_filenames_synthesis[i])){
-            //couldn't load image
-            cout << "didn't load image" << endl;
-        } 
-        
-        if(image3.loadImage(_saved_filenames_synthesis[i])){
-            image3.loadImage(_saved_filenames_synthesis[i]);
             //cout << "_show_image = true;" << endl;
             _show_image = true;
             _image_shown = false;
@@ -552,8 +477,6 @@ void ShapeFromShadingAnalysis::draw()
             
         case STATE_DISPLAY_RESULTS:
         {   
-         //   cout << "STATE_DISPLAY_RESULTS...\n" << endl;
-            
             if (_frame_cnt > 2)
             {
                 _image_shown = true;
@@ -562,23 +485,50 @@ void ShapeFromShadingAnalysis::draw()
             
             _frame_cnt++;
             
+            ofEnableAlphaBlending();
+            glShadeModel(GL_SMOOTH);
+            glLineWidth(line_width);
+            glPointSize(point_size);
+            glEnable(GL_POINT_SMOOTH);
+            
+            //RefractiveIndex::cam.begin();
+            
+            ofTranslate(tx, ty, tz);
+            ofRotateX(rx); ofRotateY(ry); ofRotateZ(rz);
+            glScalef(1.5, 1, 1);
+            
             if (_show_image)
-            {  
+                image2.setFromPixels(image1.getPixels(), image1.width, image1.height, OF_IMAGE_COLOR);
-            //    cout << "_show_image...\n" << endl;
             
-                ofEnableAlphaBlending();
+            image2.bind();        
             
-                ofSetColor(255, 255, 255);
+            RefractiveIndex::_shader.begin();
-                image2.setFromPixels(image3.getPixels(),image3.width,image3.height, OF_IMAGE_COLOR);
-                image2.draw(0,0, ofGetWidth(), ofGetHeight());
             
-                ofDisableAlphaBlending();
+            RefractiveIndex::_shader.setUniform1i("algo", algo);
+            RefractiveIndex::_shader.setUniform1f("scale", scale);
+            RefractiveIndex::_shader.setUniform1i("tex0", 0);
+            
+            switch (draw_style) {
+                case VERTS:
+                    RefractiveIndex::_mesh_vbo.drawVertices();
+                    break;
+                case WIRE:
+                    RefractiveIndex::_mesh_vbo.drawWireframe();
+                    break;
+                case FACE:
+                    RefractiveIndex::_mesh_vbo.drawFaces();
+                    break;            
             }
             
-            // display results of the synthesis
+            RefractiveIndex::_shader.end();                
-            _RUN_DONE = true;
+            
+            image2.unbind();
+            
+            //RefractiveIndex::cam.end();    
+            
             break;
 
+            
         }
             
             

src/ShapeFromShadingAnalysis.h

@@ -55,31 +55,14 @@ protected:
     float   c, _frame_cnt, _frame_cnt_max, _anim_cnt_max;
    
     bool _show_image, _image_shown;
+    
     ofImage         image1;
     ofImage         image2; 
-    ofImage         image3;
-    ofImage         image4;
-    ofImage         image5; 
-    ofImage         image6; 
     
-    ofxCvColorImage         cvColorImage1;
+    int algo;
-    ofxCvColorImage         cvColorImage2;
+    int scale;
-    ofxCvColorImage         cvColorImage3;
+    int draw_style;   
-    ofxCvColorImage         cvColorImage4;
+    float line_width;
-    ofxCvColorImage         cvColorImage5;
+    float point_size;
-    ofxCvColorImage         cvColorImage6;
-    
-    ofxCvGrayscaleImage 	cvGrayDiff1;
-    ofxCvGrayscaleImage 	cvGrayDiff2;
-    
-    ofxCvGrayscaleImage 	cvGrayImage1;
-    ofxCvGrayscaleImage 	cvGrayImage2;
-    ofxCvGrayscaleImage 	cvGrayImage3;
-    ofxCvGrayscaleImage 	cvGrayImage4;
-    
-    ofxCvContourFinder      cvContourFinder1;
-    
-    //this is the temporary container to allow us to convert and save out greyscale images
-    ofxCvColorImage         cvConvertorImage;
     
 };

src/StrobeAnalysis.cpp

@@ -13,6 +13,12 @@ using Poco::Thread;
 #define NUMBER_RUNS     1
 #define ACQUIRE_TIME    30
 
+const int algo_default = 1;
+const int scale_default = 500;
+const int draw_style_default = 3;
+const int line_width_default = 0.5f;
+const float point_size_default = 0.5f;
+
 void StrobeAnalysis::setup(int camWidth, int camHeight)
 {
     AbstractAnalysis::setup(camWidth, camHeight);
@@ -48,50 +54,24 @@ void StrobeAnalysis::setup(int camWidth, int camHeight)
     
     image1.clear();
     image2.clear();
-    image3.clear();  
+    image1.clear();
-    image4.clear();
+    image2.clear();
-    image5.clear();
     
     //  images use for drawing the synthesized files to the screen ///
     image1.setUseTexture(false);  // the non texture image that is needed to first load the image
     image2.setUseTexture(true);   // the image that needs to get written to the screen which takes the content of image1
     
-    //  images used for re-loading and saving out the synthesized files ///
-    image3.setUseTexture(false);  
-    image4.setUseTexture(false);
-    image5.setUseTexture(false);
-    
     image1.allocate(RefractiveIndex::_vid_w,RefractiveIndex::_vid_h,  OF_IMAGE_COLOR);
     image2.allocate(RefractiveIndex::_vid_w,RefractiveIndex::_vid_h,  OF_IMAGE_COLOR);
-    image3.allocate(RefractiveIndex::_vid_w,RefractiveIndex::_vid_h,  OF_IMAGE_COLOR);  
-    image4.allocate(RefractiveIndex::_vid_w,RefractiveIndex::_vid_h,  OF_IMAGE_COLOR);
-    image5.allocate(RefractiveIndex::_vid_w,RefractiveIndex::_vid_h,  OF_IMAGE_COLOR);
     
-   // cout << "RefractiveIndex::_vid_w " << RefractiveIndex::_vid_w << endl;
-   // cout << "RefractiveIndex::_vid_h " << RefractiveIndex::_vid_h << endl;
     
-    // clear() apparently fixes the "OF_WARNING: in allocate, reallocating a ofxCvImage" 
+    ////---------
-    // that we're getting in OSX/Windows and is maybe crashing Windows
-    // http://forum.openframeworks.cc/index.php?topic=1867.0
-    cvColorImage1.clear();
-	cvGrayImage1.clear();
-    cvGrayDiff1.clear();
     
-    cvColorImage2.clear();
+    algo = RefractiveIndex::XML.getValue("config:algorithms:strobe:algo", algo_default);
-	cvGrayImage2.clear();
+    scale = RefractiveIndex::XML.getValue("config:algorithms:strobe:scale", scale_default);
-    cvGrayDiff2.clear();
+    draw_style = RefractiveIndex::XML.getValue("config:algorithms:strobe:draw_style", draw_style_default);
-    
+    line_width = RefractiveIndex::XML.getValue("config:algorithms:strobe:line_width", line_width_default);        
-    cvConvertorImage.clear();    
+    point_size = RefractiveIndex::XML.getValue("config:algorithms:strobe:point_size", point_size_default);
-    
-    cvColorImage1.allocate(RefractiveIndex::_vid_w,RefractiveIndex::_vid_h);
-	cvGrayImage1.allocate(RefractiveIndex::_vid_w,RefractiveIndex::_vid_h);
-    cvGrayDiff1.allocate(RefractiveIndex::_vid_w,RefractiveIndex::_vid_h);
-    
-    cvColorImage2.allocate(RefractiveIndex::_vid_w,RefractiveIndex::_vid_h);
-	cvGrayImage2.allocate(RefractiveIndex::_vid_w,RefractiveIndex::_vid_h);
-    cvGrayDiff2.allocate(RefractiveIndex::_vid_w,RefractiveIndex::_vid_h);
-    
-    cvConvertorImage.allocate(RefractiveIndex::_vid_w,RefractiveIndex::_vid_h);
     
 }
 
@@ -128,100 +108,45 @@ void StrobeAnalysis::acquire()
 
 void StrobeAnalysis::synthesise()
 {
-   // cout << "StrobeAnalysis::saving synthesis...\n";
+    // we don't need to synthesise
-    if(_state == STATE_STOP) return;
+    return;
     
-    for(float i=1;i<_saved_filenames_analysis.size()-1;i++){
+    /*
      
-    //    cout << "StrobeAnalysis::synthesis FOR LOOP...\n";
+     //cout << "IResponseAnalysis::saving synthesis...\n";
+     if(_state == STATE_STOP) return;
      
-    //    cout << "_saved_filenames_analysis[i]" << _saved_filenames_analysis[i] << endl;
+     _RUN_DONE = false;
      
-        if(_state == STATE_STOP) return;
+     // _saved_filenames_synthesis has processed all the files in the analysis images folder
-        
+     while(!_RUN_DONE && _state != STATE_STOP)
-        if(!image1.loadImage(_saved_filenames_analysis[i])){
+     Thread::sleep(3);
-            //couldn't load image
+     */
-    //        cout << "didn't load image" << endl;
-        } 
-        
-        if(image1.loadImage(_saved_filenames_analysis[i])){
-    //        cout << "LOADED image1!!!" << endl;
-            if(image5.loadImage(_saved_filenames_analysis[i+1])){
-                
-                ///////////////////////// PROCESS THE SAVED CAMERA IMAGES OF SHIT TO THE IMAGES //////////////////////////
-                
-                cvColorImage1.setFromPixels(image1.getPixels(), image1.width, image1.height);
-                cvColorImage2.setFromPixels(image5.getPixels(), image5.width, image5.height);
-            
-                cvColorImage1.convertToGrayscalePlanarImage(cvGrayImage1, 1);
-                cvColorImage2.convertToGrayscalePlanarImage(cvGrayImage2, 1);
-                
-                cvGrayDiff1.absDiff(cvGrayImage2, cvGrayImage1);
-                cvGrayDiff1.dilate();
-                cvGrayDiff1.dilate();
-                cvGrayDiff1.contrastStretch();
-               
-                /////////////////////////////////// SAVE TO DISK IN THE SYNTHESIS FOLDER ////////////////////////////////
-                string file_name;
-                
-                file_name = ofToString(_synth_save_cnt, 2)+"_StrobeAnalysis_"+ofToString(_run_cnt,2)+".jpg";
-                
-        
-                //<---- THE OLD WAY OF SAVING - works on OSX but generates BLACK FRAMES on WINDOWS ---->
-                // ofSaveImage(cvGrayImage1.getPixelsRef(),_whole_file_path_synthesis+"/"+file_name, OF_IMAGE_QUALITY_BEST);
-                
-                
-                //<---- NEW SAVING - seems to fix WINDOWS saving out BLACK FRAMES PROBLEM ---->
-                //ofImage image;
-                //image.allocate(cvGrayImage1.width, cvGrayImage1.height, OF_IMAGE_GRAYSCALE);    
-            
-                //*** This needs to be here for OSX of we get a BAD ACCESS ERROR. DOES IT BREAK WINDOWS? ***//
-                //image.setUseTexture(false);  
-                
-                //image.setFromPixels(cvGrayDiff1.getPixels(), cvGrayDiff1.width, cvGrayDiff1.height,OF_IMAGE_GRAYSCALE);
-                //image.saveImage(_whole_file_path_synthesis+"/"+file_name);
-                
-                //_saved_filenames_synthesis.push_back(_whole_file_path_synthesis+"/"+file_name);
-              
-                
-                
-                // <--- REALLY NEW SAVING METHOD --- 26 feb 2012 --- consolidated the save function into Abstract Analysis> ///
-                cvConvertorImage.setFromGrayscalePlanarImages(cvGrayDiff1,cvGrayDiff1,cvGrayDiff1);
-                
-                saveImageSynthesis(file_name, &cvConvertorImage, OF_IMAGE_GRAYSCALE);
-                _synth_save_cnt++;
-                
-                
-            }
-        }
-    }
-    
-    // _saved_filenames_synthesis has processed all the files in the analysis images folder
-    while(!_RUN_DONE && _state != STATE_STOP)
-        Thread::sleep(3); 
 }
 
 void StrobeAnalysis::displayresults()
 {
     
-    for(float i=1;i<_saved_filenames_synthesis.size();i++){
+    for(float i=1;i<_saved_filenames_analysis.size();i++){
         
         if(_state == STATE_STOP) return;
         
-    //    cout << "_saved_filenames_analysis[i] - " << _saved_filenames_synthesis[i] << endl;
+        //cout << "_saved_filenames_analysis[i] - " << _saved_filenames_synthesis[i] << endl;
         
         while(!_image_shown){
             Thread::sleep(2);
             //cout << "!_image_shown" << endl;
         }
         
-        if(!image3.loadImage(_saved_filenames_synthesis[i])){
+        _show_image = false;
+        
+        
+        if(!image1.loadImage(_saved_filenames_analysis[i])){
             //couldn't load image
-      //      cout << "didn't load image" << endl;
+            cout << "didn't load image" << endl;
         } 
         
-        if(image3.loadImage(_saved_filenames_synthesis[i])){
+        if(image1.loadImage(_saved_filenames_analysis[i])){
-            image3.loadImage(_saved_filenames_synthesis[i]);
             //cout << "_show_image = true;" << endl;
             _show_image = true;
             _image_shown = false;
@@ -381,8 +306,6 @@ void StrobeAnalysis::draw()
         case STATE_DISPLAY_RESULTS:
         {
             
-         //   cout << "STATE_DISPLAY_RESULTS...\n" << endl;
-            
             if (_frame_cnt > 2)
             {
                 _image_shown = true;
@@ -391,21 +314,47 @@ void StrobeAnalysis::draw()
             
             _frame_cnt++;
             
+            ofEnableAlphaBlending();
+            glShadeModel(GL_SMOOTH);
+            glLineWidth(line_width);
+            glPointSize(point_size);
+            glEnable(GL_POINT_SMOOTH);
+            
+            //RefractiveIndex::cam.begin();
+            
+            ofTranslate(tx, ty, tz);
+            ofRotateX(rx); ofRotateY(ry); ofRotateZ(rz);
+            glScalef(1.5, 1, 1);
+            
             if (_show_image)
-            {  
+                image2.setFromPixels(image1.getPixels(), image1.width, image1.height, OF_IMAGE_COLOR);
-         //       cout << "_show_image...\n" << endl;
             
-                ofEnableAlphaBlending();
+            image2.bind();        
             
-                ofSetColor(255, 255, 255);
+            RefractiveIndex::_shader.begin();
-                image2.setFromPixels(image3.getPixels(),image3.width,image3.height, OF_IMAGE_COLOR);
-                image2.draw(0,0, ofGetWidth(), ofGetHeight());
             
-                ofDisableAlphaBlending();
+            RefractiveIndex::_shader.setUniform1i("algo", algo);
+            RefractiveIndex::_shader.setUniform1f("scale", scale);
+            RefractiveIndex::_shader.setUniform1i("tex0", 0);
+            
+            switch (draw_style) {
+                case VERTS:
+                    RefractiveIndex::_mesh_vbo.drawVertices();
+                    break;
+                case WIRE:
+                    RefractiveIndex::_mesh_vbo.drawWireframe();
+                    break;
+                case FACE:
+                    RefractiveIndex::_mesh_vbo.drawFaces();
+                    break;            
             }
             
-            // display results of the synthesis
+            RefractiveIndex::_shader.end();                
-            _RUN_DONE = true;
+            
+            image2.unbind();
+            
+            //RefractiveIndex::cam.end();    
+            
             break;            
 
 

src/StrobeAnalysis.h

@@ -41,31 +41,14 @@ protected:
     float   c, _frame_cnt, _frame_cnt_max, _anim_cnt_max;
     
     bool _show_image, _image_shown;
+    
     ofImage         image1;
     ofImage         image2; 
-    ofImage         image3;
-    ofImage         image4;
-    ofImage         image5; 
-    ofImage         image6; 
     
-    ofxCvColorImage         cvColorImage1;
+    int algo;
-    ofxCvColorImage         cvColorImage2;
+    int scale;
-    ofxCvColorImage         cvColorImage3;
+    int draw_style;   
-    ofxCvColorImage         cvColorImage4;
+    float line_width;
-    ofxCvColorImage         cvColorImage5;
+    float point_size; 
-    ofxCvColorImage         cvColorImage6;
-    
-    ofxCvGrayscaleImage 	cvGrayDiff1;
-    ofxCvGrayscaleImage 	cvGrayDiff2;
-    
-    ofxCvGrayscaleImage 	cvGrayImage1;
-    ofxCvGrayscaleImage 	cvGrayImage2;
-    ofxCvGrayscaleImage 	cvGrayImage3;
-    ofxCvGrayscaleImage 	cvGrayImage4;
-    
-    ofxCvContourFinder      cvContourFinder1;
-    
-    //this is the temporary container to allow us to convert and save out greyscale images
-    ofxCvColorImage         cvConvertorImage;    
 
 };