Compare commits
3 Commits
| Author | SHA1 | Date | |
|---|---|---|---|
 Jamie Allen
|
327830a581 | ||
|
Jamie Allen
|
877123a2db | ||
|
Jamie Allen
|
feedecfe04 |
+2
-1
@@ -1 +1,2 @@
|
||||
.DS_Store
|
||||
|
||||
src/.DS_Store
|
||||
|
||||
+37
-107
@@ -1,115 +1,45 @@
|
||||
<!-- THIS FILE NEEDS TO GO IN THE APPLICATION /data/ folder -->
|
||||
|
||||
<config>
|
||||
<mode>analysing</mode>
|
||||
<camera>
|
||||
<id>1</id>
|
||||
<width>640</width>
|
||||
<height>480</height>
|
||||
</camera>
|
||||
<display>
|
||||
<fps>30</fps>
|
||||
</display>
|
||||
<locale>
|
||||
<name>FUTURE</name>
|
||||
</locale>
|
||||
<camera>
|
||||
<id>1</id>
|
||||
<width>640</width>
|
||||
<height>480</height>
|
||||
</camera>
|
||||
<display>
|
||||
<fps>30</fps>
|
||||
</display>
|
||||
<locale>
|
||||
<name>SWANSEA</name>
|
||||
</locale>
|
||||
|
||||
<analysis_NUM_RUN>
|
||||
<NUM_RUN_shadowscapes> 1 </NUM_RUN_shadowscapes>
|
||||
<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_NUM_RUN>
|
||||
<NUM_RUN_shadowscapes> 3 </NUM_RUN_shadowscapes>
|
||||
<NUM_RUN_relaxrate> 3 </NUM_RUN_relaxrate>
|
||||
<NUM_RUN_iresponse> 3 </NUM_RUN_iresponse>
|
||||
<NUM_RUN_shapefromshading> 3 </NUM_RUN_shapefromshading>
|
||||
<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>
|
||||
<acquiretime_shadowscapes> 5 </acquiretime_shadowscapes>
|
||||
<acquiretime_relaxrate> 5 </acquiretime_relaxrate>
|
||||
<acquiretime_iresponse> 5 </acquiretime_iresponse>
|
||||
<acquiretime_shapefromshading> 5 </acquiretime_shapefromshading>
|
||||
<acquiretime_strobe> 5 </acquiretime_strobe>
|
||||
<acquiretime_camnoise> 5 </acquiretime_camnoise>
|
||||
<acquiretime_colorsingle> 5 </acquiretime_colorsingle>
|
||||
<acquiretime_colormulti> 5 </acquiretime_colormulti>
|
||||
<acquiretime_diffnoise> 5 </acquiretime_diffnoise>
|
||||
</analysis_time>
|
||||
<analysis_time>
|
||||
<acquiretime_shadowscapes> 30 </acquiretime_shadowscapes>
|
||||
<acquiretime_relaxrate> 30 </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> 40 </acquiretime_colormulti>
|
||||
<acquiretime_diffnoise> 30 </acquiretime_diffnoise>
|
||||
</analysis_time>
|
||||
|
||||
<viewport>
|
||||
<tx>0</tx>
|
||||
<ty>-20</ty>
|
||||
<tz>-400</tz>
|
||||
<rx>-10</rx>
|
||||
<ry>0</ry>
|
||||
<rz>0</rz>
|
||||
</viewport>
|
||||
|
||||
<algorithms>
|
||||
<vertices_per_frame>1000</vertices_per_frame>
|
||||
<pixel_per_vertex>4</pixel_per_vertex>
|
||||
<colormulti>
|
||||
<algo>2</algo>
|
||||
<scale>1</scale>
|
||||
<draw_style>2</draw_style>
|
||||
<line_width>0.5</line_width>
|
||||
</colormulti>
|
||||
<colorsingle>
|
||||
<algo>2</algo>
|
||||
<scale>1</scale>
|
||||
<draw_style>2</draw_style>
|
||||
<line_width>0.5</line_width>
|
||||
</colorsingle>
|
||||
<relaxrate>
|
||||
<algo>1</algo>
|
||||
<scale>500</scale>
|
||||
<draw_style>1</draw_style>
|
||||
<line_width>2</line_width>
|
||||
<point_size>2</point_size>
|
||||
</relaxrate>
|
||||
<diffnoise>
|
||||
<algo>1</algo>
|
||||
<scale>500</scale>
|
||||
<draw_style>1</draw_style>
|
||||
<line_width>2</line_width>
|
||||
<point_size>2</point_size>
|
||||
</diffnoise>
|
||||
<shapeshade>
|
||||
<algo>1</algo>
|
||||
<scale>500</scale>
|
||||
<draw_style>1</draw_style>
|
||||
<line_width>2</line_width>
|
||||
<point_size>2</point_size>
|
||||
</shapeshade>
|
||||
<strobe>
|
||||
<algo>1</algo>
|
||||
<scale>500</scale>
|
||||
<draw_style>1</draw_style>
|
||||
<line_width>2</line_width>
|
||||
<point_size>2</point_size>
|
||||
</strobe>
|
||||
<camnoise>
|
||||
<algo>1</algo>
|
||||
<scale>500</scale>
|
||||
<draw_style>1</draw_style>
|
||||
<line_width>2</line_width>
|
||||
<point_size>2</point_size>
|
||||
</camnoise>
|
||||
<shadowscapes>
|
||||
<algo>4</algo>
|
||||
<scale>500</scale>
|
||||
<draw_style>2</draw_style>
|
||||
<line_width>2</line_width>
|
||||
</shadowscapes>
|
||||
<iresponse>
|
||||
<algo>1</algo>
|
||||
<scale>500</scale>
|
||||
<draw_style>1</draw_style>
|
||||
<line_width>2</line_width>
|
||||
<point_size>2</point_size>
|
||||
</iresponse>
|
||||
</algorithms>
|
||||
<relaxrate>
|
||||
<threshold>51</threshold>
|
||||
<maxblobs>25</maxblobs>
|
||||
</relaxrate>
|
||||
|
||||
</config>
|
||||
@@ -1,31 +0,0 @@
|
||||
<!-- THIS FILE NEEDS TO GO IN THE APPLICATION /data/ folder -->
|
||||
|
||||
<config>
|
||||
<display>
|
||||
<fps>30</fps>
|
||||
</display>
|
||||
<locale>
|
||||
<name>DRAWING</name>
|
||||
</locale>
|
||||
|
||||
<viewport>
|
||||
<tx>0</tx>
|
||||
<ty>-0</ty>
|
||||
<tz>-0</tz>
|
||||
<rx>0</rx>
|
||||
<ry>0</ry>
|
||||
<rz>0</rz>
|
||||
</viewport>
|
||||
|
||||
<renderer>
|
||||
<edit>true</edit>
|
||||
<vertices_per_frame>1000</vertices_per_frame>
|
||||
<pixel_per_vertex>1</pixel_per_vertex>
|
||||
<algorithm>
|
||||
<algo>3</algo>
|
||||
<scale>0.71</scale>
|
||||
<draw_style>3</draw_style>
|
||||
<line_width>0.1</line_width>
|
||||
</algorithm>
|
||||
</renderer>
|
||||
</config>
|
||||
@@ -1,372 +0,0 @@
|
||||
/*
|
||||
~ 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;
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
@@ -1,148 +0,0 @@
|
||||
/*
|
||||
~ 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()
|
||||
{
|
||||
|
||||
}
|
||||
-130
@@ -1,130 +0,0 @@
|
||||
/*
|
||||
~ 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));
|
||||
}
|
||||
}
|
||||
|
||||
@@ -1,18 +0,0 @@
|
||||
#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);
|
||||
|
||||
}
|
||||
@@ -1,127 +0,0 @@
|
||||
#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();
|
||||
}
|
||||
|
||||
|
||||
}
|
||||
@@ -1,11 +0,0 @@
|
||||
#version 120
|
||||
|
||||
void main()
|
||||
{
|
||||
|
||||
gl_FrontColor = gl_Color;
|
||||
gl_TexCoord[0] = gl_MultiTexCoord0;
|
||||
gl_Position = gl_Vertex;
|
||||
|
||||
|
||||
}
|
||||
+80
-96
@@ -15,11 +15,6 @@
|
||||
|
||||
#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
|
||||
@@ -32,22 +27,6 @@
|
||||
#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;
|
||||
|
||||
@@ -61,64 +40,8 @@ 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;
|
||||
@@ -174,32 +97,42 @@ void RefractiveIndex::setup()
|
||||
|
||||
_analysisAdapator = NULL;
|
||||
|
||||
_pixels.allocate(_vid_w, _vid_h, OF_IMAGE_COLOR_ALPHA);
|
||||
|
||||
|
||||
setup_shader_vbo();
|
||||
//getting a warning from the OFlog that the pixels aren't allocated
|
||||
//void ofPixels::allocate(int w, int h, ofImageType type)
|
||||
_pixels.allocate(_vid_w, _vid_h, OF_IMAGE_COLOR);
|
||||
|
||||
|
||||
//TODO: whichever one of these is first - it always runs twice ?
|
||||
|
||||
_analysisVector.push_back(new ShadowScapesAnalysis(V)); //1
|
||||
_analysisVector.push_back(new ShadowScapesAnalysis(H)); //2
|
||||
_analysisVector.push_back(new ShadowScapesAnalysis(D)); //3
|
||||
_analysisVector.push_back(new RelaxRateAnalysis()); //4
|
||||
_analysisVector.push_back(new IResponseAnalysis()); //5
|
||||
_analysisVector.push_back(new ShapeFromShadingAnalysis()); //6
|
||||
_analysisVector.push_back(new StrobeAnalysis()); //7
|
||||
_analysisVector.push_back(new CamNoiseAnalysis()); //8
|
||||
_analysisVector.push_back(new ColorSingleAnalysis()); //9
|
||||
_analysisVector.push_back(new ColorMultiAnalysis()); //10
|
||||
_analysisVector.push_back(new DiffNoiseAnalysis()); //11
|
||||
_analysisVector.push_back(new ShadowScapesAnalysis(V));
|
||||
_analysisVector.push_back(new ShadowScapesAnalysis(H));
|
||||
_analysisVector.push_back(new ShadowScapesAnalysis(D));
|
||||
|
||||
_analysisVector.push_back(new RelaxRateAnalysis());
|
||||
|
||||
|
||||
_analysisVector.push_back(new IResponseAnalysis());
|
||||
|
||||
_analysisVector.push_back(new ShapeFromShadingAnalysis());
|
||||
|
||||
_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)
|
||||
@@ -240,6 +173,7 @@ void RefractiveIndex::state_analysis()
|
||||
_currentAnalysisIndx = 0;
|
||||
_currentAnalysis = _analysisVector.at(_currentAnalysisIndx++);
|
||||
_state = ISTATE_START;
|
||||
//_state = ISTATE_END;
|
||||
} else {
|
||||
_currentAnalysis = _analysisVector.at(_currentAnalysisIndx++);
|
||||
_state = ISTATE_START;
|
||||
@@ -271,6 +205,9 @@ 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);
|
||||
|
||||
@@ -309,10 +246,15 @@ 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)
|
||||
@@ -420,6 +362,48 @@ 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()
|
||||
|
||||
@@ -11,15 +11,9 @@
|
||||
#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:
|
||||
@@ -38,8 +32,6 @@ public:
|
||||
void stop_analysis();
|
||||
void state_analysis();
|
||||
|
||||
void setup_shader_vbo();
|
||||
|
||||
// ofx
|
||||
void keyPressed (int key);
|
||||
void keyReleased(int key){;}
|
||||
@@ -77,16 +69,4 @@ 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;
|
||||
|
||||
|
||||
};
|
||||
@@ -1,320 +0,0 @@
|
||||
/*
|
||||
RefractiveIndexRenderer.cpp - RefractiveIndexRenderer library
|
||||
Copyright (c) 2013 Copenhagen Institute of Interaction Design.
|
||||
All right reserved.
|
||||
|
||||
This library is free software: you can redistribute it and/or modify
|
||||
it under the terms of the GNU Lesser Public License as published by
|
||||
the Free Software Foundation, either version 3 of the License, or
|
||||
(at your option) any later version.
|
||||
|
||||
This library is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU Lesser Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Lesser Public License
|
||||
along with Foobar. If not, see <http://www.gnu.org/licenses/>.
|
||||
|
||||
+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
|
||||
+ author: dviid
|
||||
+ contact: dviid@labs.ciid.dk
|
||||
*/
|
||||
|
||||
#include "RefractiveIndexRenderer.h"
|
||||
|
||||
// of
|
||||
#include "ofSystemUtils.h"
|
||||
|
||||
// of addons
|
||||
#include "ofxFileHelper.h"
|
||||
|
||||
const int VPF = 1000;
|
||||
const int PPV = 4;
|
||||
|
||||
int W = 1280, INPUT_W = 0, H = 800, INPUT_H = 0, SIZE = 0;
|
||||
|
||||
bool killnow = false;
|
||||
bool go = false;
|
||||
bool edit = false;
|
||||
|
||||
ofTrueTypeFont font;
|
||||
ofImage image;
|
||||
|
||||
const int algo_default = 1;
|
||||
const float scale_default = 1;
|
||||
const int draw_style_default = 3;
|
||||
const int line_width_default = 0.5f;
|
||||
const float point_size_default = 0.5f;
|
||||
|
||||
//viewport
|
||||
float tx, ty, tz, rx, ry, rz;
|
||||
|
||||
|
||||
void RefractiveIndexRenderer::setup(){
|
||||
|
||||
ofSetLogLevel(OF_LOG_VERBOSE);
|
||||
|
||||
cout << "Loading configuration..." << endl;
|
||||
if(!XML.loadFile("config.renderer.refindx")) {
|
||||
ofLog(OF_LOG_ERROR) << "error loading config - using defaults.";
|
||||
}
|
||||
|
||||
string e = XML.getValue("config:renderer:edit", "false");
|
||||
edit = (e == "true");
|
||||
|
||||
if(!setup_dirs())
|
||||
exit();
|
||||
|
||||
if(_images_directory_filenames.size() == 0)
|
||||
exit();
|
||||
|
||||
SIZE = _images_directory_filenames.size();
|
||||
go = true;
|
||||
|
||||
// we assume all files from the images dir are the same size
|
||||
|
||||
string sample = _images_directory_filenames[(int)ofRandom(0, _images_directory_filenames.size() -1)];
|
||||
if(!image.loadImage(sample))
|
||||
exit();
|
||||
INPUT_W = image.getWidth();
|
||||
INPUT_H = image.getHeight();
|
||||
|
||||
// allocate pixels data
|
||||
_pixels.allocate(W, H, OF_IMAGE_COLOR);
|
||||
|
||||
// allocate FBO
|
||||
_fbo.allocate(W, H, GL_RGB);
|
||||
|
||||
// allocate VBO
|
||||
setup_vbo(W, H);
|
||||
|
||||
// create shader
|
||||
setup_shader();
|
||||
|
||||
// set index count (progess in rendering + saving images from FBO to drawing/ files)
|
||||
_indx = 0;
|
||||
|
||||
// set load font
|
||||
font.loadFont("/System/Library/Fonts/Geneva.dfont", 16);
|
||||
|
||||
algo = XML.getValue("config:renderer:algorithm:algo", algo_default);
|
||||
scale = XML.getValue("config:renderer:algorithm:scale", scale_default);
|
||||
draw_style = XML.getValue("config:renderer:algorithm:draw_style", draw_style_default);
|
||||
line_width = XML.getValue("config:renderer:algorithm:line_width", line_width_default);
|
||||
point_size = XML.getValue("config:renderer:algorithm:point_size", point_size_default);
|
||||
|
||||
|
||||
}
|
||||
void RefractiveIndexRenderer::update(){
|
||||
if(killnow)
|
||||
exit();
|
||||
}
|
||||
void RefractiveIndexRenderer::draw(){
|
||||
|
||||
static bool done = false;
|
||||
|
||||
if(!go) return;
|
||||
|
||||
if(!edit) {
|
||||
char str[255];
|
||||
sprintf(str, "%s \n input: %s\n output: %s \n at: %i \n total: %i", (done ? "Done!" : "Rendering"),_images_directory.c_str(), _draw_directory.c_str(), _indx, SIZE);
|
||||
font.drawString(str, 10, 50);
|
||||
}
|
||||
|
||||
if(done) return;
|
||||
|
||||
if(_indx >= _images_directory_filenames.size()) {
|
||||
if(!edit) {
|
||||
done = true;
|
||||
image.clear();
|
||||
return;
|
||||
} else {
|
||||
_indx = 0;
|
||||
}
|
||||
}
|
||||
|
||||
// clear previous image
|
||||
image.clear();
|
||||
|
||||
// load new image to render
|
||||
image.loadImage(_images_directory_filenames[_indx++]);
|
||||
image.resize(W, H);
|
||||
|
||||
// bind FBO
|
||||
_fbo.begin();
|
||||
|
||||
// camera
|
||||
_cam.begin();
|
||||
|
||||
// GL
|
||||
//ofEnableAlphaBlending();
|
||||
glShadeModel(GL_SMOOTH);
|
||||
glLineWidth(line_width);
|
||||
glPointSize(point_size);
|
||||
glEnable(GL_POINT_SMOOTH);
|
||||
|
||||
|
||||
ofTranslate(tx, ty, tz);
|
||||
ofRotateX(rx+1.5*cos(ofGetElapsedTimef())); ofRotateY(ry+1.5*sin(ofGetElapsedTimef())); ofRotateZ(rz);
|
||||
//ofRotateX(rx); ofRotateY(ry); ofRotateZ(rz);
|
||||
glScalef(1.5, 1, 1);
|
||||
|
||||
glClear(GL_COLOR_BUFFER_BIT);
|
||||
|
||||
// bind texture
|
||||
image.bind();
|
||||
|
||||
// bind shader
|
||||
_shader.begin();
|
||||
_shader.setUniform1i("algo", algo);
|
||||
_shader.setUniform1f("scale", scale);
|
||||
_shader.setUniform1i("tex0", 0);
|
||||
|
||||
// VBO draw
|
||||
switch (draw_style) {
|
||||
case VERTS:
|
||||
_mesh_vbo.drawVertices();
|
||||
break;
|
||||
case WIRE:
|
||||
_mesh_vbo.drawWireframe();
|
||||
break;
|
||||
case FACE:
|
||||
_mesh_vbo.drawFaces();
|
||||
break;
|
||||
}
|
||||
|
||||
// unbind shader
|
||||
_shader.end();
|
||||
|
||||
// unbind texture
|
||||
image.unbind();
|
||||
|
||||
_cam.end();
|
||||
|
||||
// unbind FBO
|
||||
_fbo.end();
|
||||
|
||||
if(edit) {
|
||||
_fbo.draw(0, 0);
|
||||
} else {
|
||||
std::stringstream s;
|
||||
s << _indx;
|
||||
save(_draw_directory + "/" + s.str());
|
||||
}
|
||||
|
||||
}
|
||||
void RefractiveIndexRenderer::exit(){
|
||||
ofLog(OF_LOG_ERROR) << "exit...";
|
||||
}
|
||||
void RefractiveIndexRenderer::keyPressed (int key){
|
||||
if( key =='e'){
|
||||
edit = !edit;
|
||||
_indx = 0;
|
||||
}
|
||||
}
|
||||
bool file_cmp(string f0, string f1)
|
||||
{
|
||||
int v0 = atoi(f0.substr(0, f0.find("_")).c_str());
|
||||
int v1 = atoi(f1.substr(0, f1.find("_")).c_str());
|
||||
return v0 < v1;
|
||||
}
|
||||
bool RefractiveIndexRenderer::setup_dirs(){
|
||||
|
||||
// ask for a directory
|
||||
ofFileDialogResult r = ofSystemLoadDialog("choooose da folda", true);
|
||||
if(!r.bSuccess) {
|
||||
ofSystemAlertDialog("OOOOPS.... ERROR...");
|
||||
return;
|
||||
}
|
||||
|
||||
// copy names
|
||||
_images_directory = r.filePath;
|
||||
_draw_directory = r.filePath + "/darwings";
|
||||
|
||||
// list all images in the directory and save into vector
|
||||
File dir(_images_directory);
|
||||
|
||||
if(dir.exists() && dir.isDirectory()) {
|
||||
vector<string> list;
|
||||
dir.list(list);
|
||||
|
||||
std::sort(list.begin(), list.end(), file_cmp);
|
||||
|
||||
for(int i = 0; i < list.size(); i++) {
|
||||
string filepath = _images_directory + "/" + list[i];
|
||||
_images_directory_filenames.push_back(filepath);
|
||||
}
|
||||
}
|
||||
|
||||
// create drawing directory
|
||||
if(!ofxFileHelper::doesDirectoryExist(_draw_directory))
|
||||
ofxFileHelper::makeDirectory(_draw_directory);
|
||||
|
||||
}
|
||||
void RefractiveIndexRenderer::setup_vbo(int img_width, int img_height){
|
||||
|
||||
int vertices_per_frame = XML.getValue("config:renderer:vertices_per_frame", VPF);
|
||||
int pixel_per_vertex = XML.getValue("config:renderer:pixel_per_vertex", PPV);
|
||||
|
||||
int vertices_X = img_width / pixel_per_vertex, vertices_Y = img_height / 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 * img_width, j / (float) vertices_Y * img_height));
|
||||
//_tex.push_back(ofVec2f(i * pixel_per_vertex, j * pixel_per_vertex));
|
||||
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);
|
||||
|
||||
}
|
||||
void RefractiveIndexRenderer::setup_shader(){
|
||||
|
||||
// TODO: INTEGRATE JAMIE CODE
|
||||
/*
|
||||
_shader.setGeometryOutputCount(3);
|
||||
_shader.load("rfi.vert", "rfi.frag", "rfi.geom");
|
||||
_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");
|
||||
_shader.setGeometryInputType(GL_TRIANGLES);
|
||||
_shader.setGeometryOutputType(GL_TRIANGLES);
|
||||
|
||||
printf("Maximum number of output vertices support is: %i\n", _shader.getGeometryMaxOutputCount());
|
||||
|
||||
}
|
||||
void RefractiveIndexRenderer::save(string filename){
|
||||
|
||||
// clear pixels
|
||||
_pixels.clear();
|
||||
|
||||
// copy fbo pixels to of pixels
|
||||
_fbo.readToPixels(_pixels);
|
||||
|
||||
// save pixels
|
||||
ofSaveImage(_pixels, filename+".jpg", OF_IMAGE_QUALITY_BEST);
|
||||
|
||||
}
|
||||
|
||||
@@ -1,81 +0,0 @@
|
||||
/*
|
||||
RefractiveIndexRenderer.h - RefractiveIndexRenderer library
|
||||
Copyright (c) 2012 Copenhagen Institute of Interaction Design.
|
||||
All right reserved.
|
||||
|
||||
This library is free software: you can redistribute it and/or modify
|
||||
it under the terms of the GNU Lesser Public License as published by
|
||||
the Free Software Foundation, either version 3 of the License, or
|
||||
(at your option) any later version.
|
||||
|
||||
This library is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU Lesser Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Lesser Public License
|
||||
along with Foobar. If not, see <http://www.gnu.org/licenses/>.
|
||||
|
||||
+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
|
||||
+ author: dviid
|
||||
+ contact: dviid@labs.ciid.dk
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
|
||||
// of
|
||||
#include "ofMain.h"
|
||||
#include "ofEvents.h"
|
||||
|
||||
// of addons
|
||||
#include "ofxXmlSettings.h"
|
||||
#include "ofxArcBall.h"
|
||||
|
||||
#define VERTS 1
|
||||
#define WIRE 2
|
||||
#define FACE 3
|
||||
|
||||
class RefractiveIndexRenderer : public ofBaseApp
|
||||
{
|
||||
public:
|
||||
|
||||
// of
|
||||
void setup();
|
||||
void update();
|
||||
void draw();
|
||||
void exit();
|
||||
void keyPressed (int key);
|
||||
|
||||
bool setup_dirs();
|
||||
void setup_vbo(int img_width, int img_height);
|
||||
void setup_shader();
|
||||
|
||||
void save(string filename);
|
||||
|
||||
public:
|
||||
|
||||
ofVboMesh _mesh_vbo;
|
||||
vector<ofVec3f> _verts;
|
||||
vector<ofVec2f> _tex;
|
||||
vector<unsigned int> _ind;
|
||||
|
||||
ofShader _shader;
|
||||
ofPixels _pixels;
|
||||
ofFbo _fbo;
|
||||
int _indx;
|
||||
|
||||
ofxXmlSettings XML;
|
||||
|
||||
string _images_directory;
|
||||
string _draw_directory;
|
||||
vector<string> _images_directory_filenames;
|
||||
|
||||
int algo;
|
||||
float scale;
|
||||
int draw_style;
|
||||
float line_width;
|
||||
float point_size;
|
||||
|
||||
ofxArcBall _cam;
|
||||
|
||||
};
|
||||
+3
-6
@@ -1,9 +1,8 @@
|
||||
#include "ofAppGlutWindow.h"
|
||||
#include "RefractiveIndex.h"
|
||||
#include "RefractiveIndexRenderer.h"
|
||||
|
||||
#define SCREEN_WIDTH 1280
|
||||
#define SCREEN_HEIGHT 800
|
||||
#define SCREEN_WIDTH 800
|
||||
#define SCREEN_HEIGHT 600
|
||||
|
||||
int main() {
|
||||
|
||||
@@ -23,8 +22,6 @@ int main() {
|
||||
}
|
||||
|
||||
ofSetupOpenGL(&window, SCREEN_WIDTH, SCREEN_HEIGHT, (fullscreen ? OF_FULLSCREEN : OF_WINDOW));
|
||||
//ofRunApp(new RefractiveIndex());
|
||||
ofRunApp(new RefractiveIndexRenderer());
|
||||
|
||||
ofRunApp(new RefractiveIndex());
|
||||
|
||||
}
|
||||
|
||||
+14
-96
@@ -3,85 +3,31 @@
|
||||
#include "AbstractAnalysis.h"
|
||||
#include "RefractiveIndex.h"
|
||||
#include "ofxFileHelper.h"
|
||||
#include "ofSystemUtils.h"
|
||||
|
||||
void AbstractAnalysis::setup(int camWidth, int camHeight) {
|
||||
|
||||
_cam_w = camWidth; _cam_h = camHeight;
|
||||
|
||||
if(RefractiveIndex::_mode == MODE_DRAWING) {
|
||||
ofFileDialogResult r = ofSystemLoadDialog("choooose da folda", true);
|
||||
if(!r.bSuccess) {
|
||||
ofSystemAlertDialog("OOOOPS.... ERROR...");
|
||||
return;
|
||||
}
|
||||
|
||||
_whole_file_path_analysis = r.filePath;
|
||||
_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
|
||||
void AbstractAnalysis::do_synthesize() {
|
||||
|
||||
switch(RefractiveIndex::_mode)
|
||||
{
|
||||
case MODE_ANALYSING:
|
||||
{
|
||||
for(int i = 0; i < NUM_RUN; i++) {
|
||||
for(int i = 0; i < NUM_RUN; i++) {
|
||||
|
||||
cout << "NUM_RUN: " << i << endl;
|
||||
cout << "NUM_RUN: " << i << endl;
|
||||
|
||||
_saved_filenames_analysis.clear();
|
||||
_saved_filenames_synthesis.clear();
|
||||
_saved_filenames_analysis.clear();
|
||||
_saved_filenames_synthesis.clear();
|
||||
|
||||
_state = STATE_ACQUIRING;
|
||||
acquire();
|
||||
if(_state == STATE_STOP) goto exit;
|
||||
_state = STATE_SYNTHESISING;
|
||||
synthesise();
|
||||
if(_state == STATE_STOP) goto exit;
|
||||
_state = STATE_DISPLAY_RESULTS;
|
||||
displayresults();
|
||||
}
|
||||
|
||||
break;
|
||||
}
|
||||
|
||||
case MODE_DRAWING:
|
||||
{
|
||||
ofxFileHelper fileHelperDrawing;
|
||||
if(!fileHelperDrawing.doesDirectoryExist(_whole_file_path_synthesis)){
|
||||
fileHelperDrawing.makeDirectory(_whole_file_path_synthesis);
|
||||
}
|
||||
|
||||
read_dir_create_list(_whole_file_path_analysis);
|
||||
_state = STATE_SYNTHESISING;
|
||||
synthesise();
|
||||
if(_state == STATE_STOP) goto exit;
|
||||
_state = STATE_DISPLAY_RESULTS;
|
||||
displayresults();
|
||||
|
||||
break;
|
||||
}
|
||||
_state = STATE_ACQUIRING;
|
||||
acquire();
|
||||
if(_state == STATE_STOP) goto exit;
|
||||
_state = STATE_SYNTHESISING;
|
||||
synthesise();
|
||||
if(_state == STATE_STOP) goto exit;
|
||||
_state = STATE_DISPLAY_RESULTS;
|
||||
displayresults();
|
||||
cleanup();
|
||||
}
|
||||
|
||||
exit:
|
||||
exit:
|
||||
cleanup();
|
||||
ofxFileHelper::deleteFolder(_whole_file_path_analysis);
|
||||
ofNotifyEvent(_synthesize_cb, _name);
|
||||
|
||||
}
|
||||
|
||||
void AbstractAnalysis::create_dir_allocate_images()
|
||||
@@ -131,7 +77,6 @@ void AbstractAnalysis::create_dir_allocate_images()
|
||||
|
||||
}
|
||||
|
||||
|
||||
_whole_file_path_synthesis = SYNTHESIS_PATH + RefractiveIndex::_location + "/" + _name + "/"+replaceTime;
|
||||
|
||||
if(!fileHelperSynthesis.doesDirectoryExist(_whole_file_path_synthesis)){
|
||||
@@ -149,7 +94,6 @@ void AbstractAnalysis::create_dir_allocate_images()
|
||||
fileHelperSynthesis.makeDirectory(SYNTHESIS_PATH+RefractiveIndex::_location+"/"+_name+"/"+replaceTime);
|
||||
|
||||
}
|
||||
|
||||
//////////////////////////////END DIRECTORY CREATION //////////////////////////////////////////////////
|
||||
|
||||
|
||||
@@ -172,30 +116,6 @@ void AbstractAnalysis::create_dir_allocate_images()
|
||||
|
||||
}
|
||||
|
||||
bool cmp_file(string f0, string f1)
|
||||
{
|
||||
int v0 = atoi(f0.substr(0, f0.find("_")).c_str());
|
||||
int v1 = atoi(f1.substr(0, f1.find("_")).c_str());
|
||||
return v0 < v1;
|
||||
}
|
||||
|
||||
void AbstractAnalysis::read_dir_create_list(string folder_path)
|
||||
{
|
||||
File dir(folder_path);
|
||||
|
||||
if(dir.exists() && dir.isDirectory()) {
|
||||
vector<string> list;
|
||||
dir.list(list);
|
||||
|
||||
std::sort(list.begin(), list.end(), cmp_file);
|
||||
|
||||
for(int i = 0; i < list.size(); i++) {
|
||||
string filepath = folder_path + "/" + list[i];
|
||||
_saved_filenames_analysis.push_back(filepath);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void AbstractAnalysis::saveImageAnalysis(string filename)
|
||||
{
|
||||
|
||||
@@ -204,7 +124,6 @@ void AbstractAnalysis::saveImageAnalysis(string filename)
|
||||
if (RefractiveIndex::_vidGrabber.isFrameNew())
|
||||
{
|
||||
RefractiveIndex::_pixels = RefractiveIndex::_vidGrabber.getPixelsRef(); //get ofPixels from the camera
|
||||
|
||||
} else {
|
||||
return;
|
||||
}
|
||||
@@ -262,6 +181,5 @@ void AbstractAnalysis::saveImageSynthesis(string filename, ofxCvImage* newPixels
|
||||
|
||||
_saved_filenames_synthesis.push_back(_whole_file_path_synthesis+"/"+filename);
|
||||
|
||||
|
||||
}
|
||||
|
||||
|
||||
@@ -25,7 +25,7 @@ public:
|
||||
virtual ~AbstractAnalysis(){;}
|
||||
|
||||
// generic function to set up the camera
|
||||
virtual void setup(int camWidth, int camHeight);
|
||||
virtual void setup(int camWidth, int camHeight){_cam_w = camWidth; _cam_h = camHeight;}
|
||||
|
||||
// this is the main threaded loop for a given analysis
|
||||
void do_synthesize();
|
||||
@@ -37,8 +37,6 @@ protected:
|
||||
|
||||
virtual void create_dir_allocate_images();
|
||||
|
||||
virtual void read_dir_create_list(string folder_path);
|
||||
|
||||
virtual void saveImageAnalysis(string filename);
|
||||
virtual void saveImageSynthesis(string filename, ofxCvImage* newPixels, ofImageType newType);
|
||||
|
||||
@@ -57,7 +55,6 @@ protected:
|
||||
|
||||
public:
|
||||
string _name;
|
||||
string _draw_directory;
|
||||
|
||||
// event
|
||||
ofEvent<string> _synthesize_cb;
|
||||
@@ -81,9 +78,5 @@ protected:
|
||||
int NUM_RUN;
|
||||
int NUM_SAVE_PER_RUN;
|
||||
|
||||
//viewport
|
||||
|
||||
float tx, ty, tz, rx, ry, rz;
|
||||
|
||||
friend class AnalysisAdaptor;
|
||||
};
|
||||
+122
-67
@@ -13,17 +13,8 @@ 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);
|
||||
|
||||
NUM_RUN = RefractiveIndex::XML.getValue("config:analysis_NUM_RUN:NUM_RUN_camnoise", NUMBER_RUNS);
|
||||
cout << "NUM_RUN CamNoiseAnalysis " << NUM_RUN << endl;
|
||||
//NUM_RUN = 5;
|
||||
@@ -54,25 +45,52 @@ 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();
|
||||
|
||||
algo = RefractiveIndex::XML.getValue("config:algorithms:camnoise:algo", algo_default);
|
||||
scale = RefractiveIndex::XML.getValue("config:algorithms:camnoise:scale", scale_default);
|
||||
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);
|
||||
point_size = RefractiveIndex::XML.getValue("config:algorithms:camnoise:point_size", point_size_default);
|
||||
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);
|
||||
|
||||
}
|
||||
|
||||
@@ -107,27 +125,90 @@ void CamNoiseAnalysis::acquire()
|
||||
|
||||
void CamNoiseAnalysis::synthesise()
|
||||
{
|
||||
// we don't need to synthesise
|
||||
return;
|
||||
//cout << "CamNoiseAnalysis::saving synthesis...\n";
|
||||
if(_state == STATE_STOP) return;
|
||||
|
||||
/*
|
||||
for(float i=1;i<_saved_filenames_analysis.size()-1;i++){
|
||||
|
||||
//cout << "IResponseAnalysis::saving synthesis...\n";
|
||||
if(_state == STATE_STOP) return;
|
||||
//cout << "CamNoiseAnalysis::synthesis FOR LOOP...\n";
|
||||
|
||||
_RUN_DONE = false;
|
||||
//cout << "_saved_filenames_analysis[i]" << _saved_filenames_analysis[i] << endl;
|
||||
|
||||
// _saved_filenames_synthesis has processed all the files in the analysis images folder
|
||||
while(!_RUN_DONE && _state != STATE_STOP)
|
||||
Thread::sleep(3);
|
||||
*/
|
||||
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);
|
||||
//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_analysis.size();i++){
|
||||
for(float i=1;i<_saved_filenames_synthesis.size();i++){
|
||||
|
||||
if(_state == STATE_STOP) return;
|
||||
|
||||
@@ -138,15 +219,13 @@ void CamNoiseAnalysis::displayresults()
|
||||
//cout << "!_image_shown" << endl;
|
||||
}
|
||||
|
||||
_show_image = false;
|
||||
|
||||
|
||||
if(!image1.loadImage(_saved_filenames_analysis[i])){
|
||||
if(!image3.loadImage(_saved_filenames_synthesis[i])){
|
||||
//couldn't load image
|
||||
cout << "didn't load image" << endl;
|
||||
}
|
||||
|
||||
if(image1.loadImage(_saved_filenames_analysis[i])){
|
||||
if(image3.loadImage(_saved_filenames_synthesis[i])){
|
||||
image3.loadImage(_saved_filenames_synthesis[i]);
|
||||
//cout << "_show_image = true;" << endl;
|
||||
_show_image = true;
|
||||
_image_shown = false;
|
||||
@@ -308,6 +387,8 @@ void CamNoiseAnalysis::draw()
|
||||
case STATE_DISPLAY_RESULTS:
|
||||
{
|
||||
|
||||
//cout << "STATE_DISPLAY_RESULTS...\n" << endl;
|
||||
|
||||
if (_frame_cnt > 2)
|
||||
{
|
||||
_image_shown = true;
|
||||
@@ -316,47 +397,21 @@ 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;
|
||||
|
||||
image2.bind();
|
||||
ofEnableAlphaBlending();
|
||||
|
||||
RefractiveIndex::_shader.begin();
|
||||
ofSetColor(255, 255, 255);
|
||||
image2.setFromPixels(image3.getPixels(),image3.width,image3.height, OF_IMAGE_COLOR);
|
||||
image2.draw(0,0, ofGetWidth(), ofGetHeight());
|
||||
|
||||
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;
|
||||
ofDisableAlphaBlending();
|
||||
}
|
||||
|
||||
RefractiveIndex::_shader.end();
|
||||
|
||||
image2.unbind();
|
||||
|
||||
RefractiveIndex::cam.end();
|
||||
|
||||
// display results of the synthesis
|
||||
_RUN_DONE = true;
|
||||
break;
|
||||
|
||||
}
|
||||
|
||||
+24
-6
@@ -37,13 +37,31 @@ 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;
|
||||
};
|
||||
|
||||
+116
-70
@@ -12,15 +12,8 @@ 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);
|
||||
|
||||
NUM_RUN = RefractiveIndex::XML.getValue("config:analysis_NUM_RUN:NUM_RUN_colormulti", NUMBER_RUNS);
|
||||
cout << "NUM_RUN ColorMultiAnalysis " << NUM_RUN << endl;
|
||||
//NUM_RUN = 5;
|
||||
@@ -51,21 +44,50 @@ 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();
|
||||
|
||||
algo = RefractiveIndex::XML.getValue("config:algorithms:colormulti:algo", algo_default);
|
||||
scale = RefractiveIndex::XML.getValue("config:algorithms:colormulti:scale", scale_default);
|
||||
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);
|
||||
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);
|
||||
|
||||
}
|
||||
|
||||
@@ -101,25 +123,79 @@ void ColorMultiAnalysis::acquire()
|
||||
void ColorMultiAnalysis::synthesise()
|
||||
{
|
||||
|
||||
// we don't need to synthesise
|
||||
return;
|
||||
//cout << "ColorMultiAnalysis::saving synthesis...\n";
|
||||
if(_state == STATE_STOP) return;
|
||||
|
||||
/*
|
||||
for(float i=1;i<_saved_filenames_analysis.size()-1;i++){
|
||||
|
||||
//cout << "IResponseAnalysis::saving synthesis...\n";
|
||||
if(_state == STATE_STOP) return;
|
||||
//cout << "ColorMultiAnalysis::synthesis FOR LOOP...\n";
|
||||
|
||||
_RUN_DONE = false;
|
||||
//cout << "_saved_filenames_analysis[i]" << _saved_filenames_analysis[i] << endl;
|
||||
|
||||
// _saved_filenames_synthesis has processed all the files in the analysis images folder
|
||||
while(!_RUN_DONE && _state != STATE_STOP)
|
||||
Thread::sleep(3);
|
||||
*/
|
||||
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.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_analysis.size();i++){
|
||||
for(float i=1;i<_saved_filenames_synthesis.size();i++){
|
||||
|
||||
if(_state == STATE_STOP) return;
|
||||
|
||||
@@ -130,15 +206,13 @@ void ColorMultiAnalysis::displayresults()
|
||||
//cout << "!_image_shown" << endl;
|
||||
}
|
||||
|
||||
_show_image = false;
|
||||
|
||||
|
||||
if(!image1.loadImage(_saved_filenames_analysis[i])){
|
||||
if(!image3.loadImage(_saved_filenames_synthesis[i])){
|
||||
//couldn't load image
|
||||
cout << "didn't load image" << endl;
|
||||
}
|
||||
|
||||
if(image1.loadImage(_saved_filenames_analysis[i])){
|
||||
if(image3.loadImage(_saved_filenames_synthesis[i])){
|
||||
image3.loadImage(_saved_filenames_synthesis[i]);
|
||||
//cout << "_show_image = true;" << endl;
|
||||
_show_image = true;
|
||||
_image_shown = false;
|
||||
@@ -172,8 +246,6 @@ void ColorMultiAnalysis::draw()
|
||||
//cout << "FADING IN..." << endl;
|
||||
}
|
||||
|
||||
|
||||
|
||||
if (_frame_cnt >= _fade_in_frames && _frame_cnt < _frame_cnt_max-_fade_in_frames){
|
||||
|
||||
aColor.setHsb(c, 255, 255);
|
||||
@@ -280,9 +352,8 @@ 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);
|
||||
@@ -296,6 +367,7 @@ void ColorMultiAnalysis::draw()
|
||||
|
||||
//cout << "STATE_DISPLAY_RESULTS...\n" << endl;
|
||||
|
||||
|
||||
if (_frame_cnt > 2)
|
||||
{
|
||||
_image_shown = true;
|
||||
@@ -304,48 +376,22 @@ void ColorMultiAnalysis::draw()
|
||||
|
||||
_frame_cnt++;
|
||||
|
||||
if (_show_image)
|
||||
{
|
||||
//cout << "_show_image...\n" << endl;
|
||||
|
||||
ofEnableAlphaBlending();
|
||||
glShadeModel(GL_SMOOTH);
|
||||
glLineWidth(line_width);
|
||||
ofEnableAlphaBlending();
|
||||
|
||||
RefractiveIndex::cam.begin();
|
||||
ofSetColor(255, 255, 255);
|
||||
image2.setFromPixels(image3.getPixels(),image3.width,image3.height, OF_IMAGE_COLOR);
|
||||
image2.draw(0,0, ofGetWidth(), ofGetHeight());
|
||||
|
||||
ofTranslate(tx, ty, tz);
|
||||
ofRotateX(rx); ofRotateY(ry); ofRotateZ(rz);
|
||||
glScalef(1.5, 1, 1);
|
||||
ofDisableAlphaBlending();
|
||||
}
|
||||
|
||||
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;
|
||||
}
|
||||
|
||||
RefractiveIndex::_shader.end();
|
||||
|
||||
image2.unbind();
|
||||
|
||||
RefractiveIndex::cam.end();
|
||||
|
||||
_RUN_DONE = true;
|
||||
break;
|
||||
// display results of the synthesis
|
||||
_RUN_DONE = true;
|
||||
break;
|
||||
|
||||
}
|
||||
|
||||
|
||||
@@ -31,14 +31,32 @@ 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;
|
||||
|
||||
int algo;
|
||||
int scale;
|
||||
int draw_style;
|
||||
float line_width;
|
||||
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;
|
||||
|
||||
|
||||
};
|
||||
|
||||
+265
-68
@@ -13,15 +13,8 @@ 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);
|
||||
|
||||
NUM_RUN = RefractiveIndex::XML.getValue("config:analysis_NUM_RUN:NUM_RUN_colorsingle", NUMBER_RUNS);
|
||||
cout << "NUM_RUN ColorSingleAnalysis " << NUM_RUN << endl;
|
||||
//NUM_RUN = 5;
|
||||
@@ -58,21 +51,50 @@ 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();
|
||||
|
||||
algo = RefractiveIndex::XML.getValue("config:algorithms:colorsingle:algo", algo_default);
|
||||
scale = RefractiveIndex::XML.getValue("config:algorithms:colorsingle:scale", scale_default);
|
||||
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);
|
||||
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);
|
||||
|
||||
}
|
||||
|
||||
@@ -102,33 +124,197 @@ void ColorSingleAnalysis::acquire()
|
||||
|
||||
save_timer->stop();
|
||||
|
||||
|
||||
// }
|
||||
}
|
||||
|
||||
void ColorSingleAnalysis::synthesise()
|
||||
{
|
||||
|
||||
// we don't need to synthesise
|
||||
return;
|
||||
//cout << "ColorSingleAnalysis::saving synthesis...\n";
|
||||
if(_state == STATE_STOP) return;
|
||||
|
||||
/*
|
||||
for(float i=1;i<_saved_filenames_analysis.size()-1;i++){
|
||||
|
||||
//cout << "IResponseAnalysis::saving synthesis...\n";
|
||||
if(_state == STATE_STOP) return;
|
||||
//cout << "ColorSingleAnalysis::synthesis FOR LOOP...\n";
|
||||
//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)
|
||||
Thread::sleep(3);
|
||||
*/
|
||||
image1.loadImage("Mar_02_19_00_47_2/194_9.72_1.jpg");
|
||||
image1.resize(image1.width/20, image1.height/20);
|
||||
|
||||
int width = image1.width;
|
||||
int height = image1.height;
|
||||
|
||||
// get the pixels from the image
|
||||
imagePixels = image1.getPixels();
|
||||
|
||||
// ------------------- create the vector field ------------------------------------
|
||||
|
||||
vectorCount = width * height;
|
||||
|
||||
// create a 2d vector field
|
||||
vectorField = new ofVec2f[vectorCount];
|
||||
|
||||
// set all values in vector field to 0.0
|
||||
for(int i=0; i<vectorCount; i++){
|
||||
|
||||
vectorField[i].x = 0.0;
|
||||
vectorField[i].y = 0.0;
|
||||
}
|
||||
|
||||
|
||||
// ------------------- calculate the vectors ------------------------------------
|
||||
|
||||
// loop through all of the pixels
|
||||
for(int x=1; x< width-1; x++){
|
||||
for(int y=1; y< height-1; y++){
|
||||
|
||||
char areaPixels[9];
|
||||
|
||||
// loop through the area pixels
|
||||
for(int i=-1; i<=1; i++){
|
||||
for(int j=-1; j<=1; j++){
|
||||
|
||||
// determine where to read from in the area (not optimized)
|
||||
int readPos = ((y + j) * width + (x + i)) * 3;
|
||||
|
||||
unsigned char R = imagePixels[readPos];
|
||||
unsigned char G = imagePixels[readPos+1];
|
||||
unsigned char B = imagePixels[readPos+2];
|
||||
|
||||
unsigned char BR = (0.299 * R) + (.587 * G) + (.114 * B);
|
||||
|
||||
int writePos = (j+1) * 3 + (i + 1);
|
||||
|
||||
areaPixels[writePos] = BR;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
|
||||
float dX = (areaPixels[0] + areaPixels[3] + areaPixels[6])/3 - (areaPixels[2] + areaPixels[5] + areaPixels[8])/3;
|
||||
float dY = (areaPixels[0] + areaPixels[1] + areaPixels[2])/3 - (areaPixels[6] + areaPixels[7] + areaPixels[8])/3;
|
||||
|
||||
int vectorPos = y * width + x;
|
||||
|
||||
//printf("dx %f\n", dX);
|
||||
|
||||
vectorField[vectorPos].x = dX;
|
||||
vectorField[vectorPos].y = dY;
|
||||
|
||||
//vectorField[vectorPos].x = -dY;
|
||||
//vectorField[vectorPos].y = dX;
|
||||
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
|
||||
// ------------------- normalize the vectors ------------------------------------
|
||||
|
||||
// variables for the maximum magnitude (absolute) in x and y
|
||||
float maxMagX = 1.0;
|
||||
float maxMagY = 1.0;
|
||||
|
||||
// loop through the vector field to find the maximum x and y values
|
||||
for(int i=0; i< vectorCount; i++){
|
||||
|
||||
if(fabs(vectorField[i].x) > maxMagX) maxMagX = fabs(vectorField[i].x);
|
||||
if(fabs(vectorField[i].y) > maxMagY) maxMagY = fabs(vectorField[i].y);
|
||||
}
|
||||
|
||||
// loop through the vector field to normalize the values
|
||||
for(int i=0; i< vectorCount; i++){
|
||||
|
||||
vectorField[i].x /= maxMagX;
|
||||
vectorField[i].y /= maxMagY;
|
||||
}
|
||||
|
||||
// COMMENTING OUT THE FILLER SYNTH ALGORITHM
|
||||
/*
|
||||
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.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_analysis.size();i++){
|
||||
|
||||
if(_state == STATE_STOP) return;
|
||||
|
||||
_show_image = true;
|
||||
_image_shown = false;
|
||||
|
||||
//cout << "_saved_filenames_analysis[i] - " << _saved_filenames_synthesis[i] << endl;
|
||||
|
||||
while(!_image_shown){
|
||||
Thread::sleep(2);
|
||||
//cout << "!_image_shown" << endl;
|
||||
}
|
||||
|
||||
/*
|
||||
for(float i=1;i<_saved_filenames_synthesis.size();i++){
|
||||
|
||||
if(_state == STATE_STOP) return;
|
||||
|
||||
@@ -139,20 +325,19 @@ void ColorSingleAnalysis::displayresults()
|
||||
//cout << "!_image_shown" << endl;
|
||||
}
|
||||
|
||||
_show_image = false;
|
||||
|
||||
|
||||
if(!image1.loadImage(_saved_filenames_analysis[i])){
|
||||
if(!image3.loadImage(_saved_filenames_synthesis[i])){
|
||||
//couldn't load image
|
||||
cout << "didn't load image" << endl;
|
||||
}
|
||||
|
||||
if(image1.loadImage(_saved_filenames_analysis[i])){
|
||||
if(image3.loadImage(_saved_filenames_synthesis[i])){
|
||||
image3.loadImage(_saved_filenames_synthesis[i]);
|
||||
//cout << "_show_image = true;" << endl;
|
||||
_show_image = true;
|
||||
_image_shown = false;
|
||||
}
|
||||
}
|
||||
*/
|
||||
|
||||
}
|
||||
|
||||
@@ -163,8 +348,6 @@ void ColorSingleAnalysis::draw()
|
||||
switch (_state) {
|
||||
case STATE_ACQUIRING:
|
||||
{
|
||||
|
||||
|
||||
if (_frame_cnt < _frame_cnt_max)
|
||||
{
|
||||
|
||||
@@ -310,6 +493,47 @@ void ColorSingleAnalysis::draw()
|
||||
case STATE_DISPLAY_RESULTS:
|
||||
{
|
||||
|
||||
cout << "case STATE_DISPLAY_RESULTS = true" << endl;
|
||||
|
||||
int width = image1.width;
|
||||
int height = image1.height;
|
||||
float spacing = 10;
|
||||
|
||||
if (_frame_cnt > 2000)
|
||||
{
|
||||
_image_shown = true;
|
||||
_frame_cnt=0;
|
||||
}
|
||||
|
||||
_frame_cnt++;
|
||||
|
||||
if (_show_image)
|
||||
{
|
||||
|
||||
|
||||
cout << "_show_image = true" << endl;
|
||||
|
||||
for(int x=0; x<width; x++){
|
||||
|
||||
float xPos = (float) x * spacing + 5;
|
||||
|
||||
for(int y=0; y<height; y++){
|
||||
float yPos = (float)y * spacing + 5;
|
||||
glPushMatrix();
|
||||
ofLine(xPos, yPos, xPos+(vectorField[y*width+x].x*spacing), yPos+(vectorField[y*width+x].y*spacing));
|
||||
glPopMatrix();
|
||||
}
|
||||
}
|
||||
|
||||
//this is where we save the full-frame software output to file... after the vectors, etc. are rendered...
|
||||
//saveImageSynthesis(file_name, &cvColorImage1, OF_IMAGE_COLOR);
|
||||
|
||||
}
|
||||
|
||||
_RUN_DONE = true;
|
||||
break;
|
||||
|
||||
/*
|
||||
//cout << "STATE_DISPLAY_RESULTS...\n" << endl;
|
||||
|
||||
if (_frame_cnt > 2)
|
||||
@@ -320,54 +544,27 @@ 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;
|
||||
|
||||
image2.bind();
|
||||
ofEnableAlphaBlending();
|
||||
|
||||
RefractiveIndex::_shader.begin();
|
||||
ofSetColor(255, 255, 255);
|
||||
image2.setFromPixels(image3.getPixels(),image3.width,image3.height, OF_IMAGE_COLOR);
|
||||
image2.draw(0,0, ofGetWidth(), ofGetHeight());
|
||||
|
||||
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;
|
||||
ofDisableAlphaBlending();
|
||||
}
|
||||
|
||||
RefractiveIndex::_shader.end();
|
||||
|
||||
image2.unbind();
|
||||
|
||||
RefractiveIndex::cam.end();
|
||||
|
||||
// display results of the synthesis
|
||||
_RUN_DONE = true;
|
||||
break;
|
||||
|
||||
*/
|
||||
|
||||
}
|
||||
|
||||
default:
|
||||
break;
|
||||
break;
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
@@ -38,13 +38,35 @@ 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;
|
||||
|
||||
int algo;
|
||||
int scale;
|
||||
int draw_style;
|
||||
float line_width;
|
||||
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;
|
||||
|
||||
unsigned char * imagePixels;
|
||||
int vectorCount;
|
||||
ofVec2f * vectorField;
|
||||
|
||||
};
|
||||
|
||||
+114
-65
@@ -13,16 +13,8 @@ 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);
|
||||
|
||||
NUM_RUN = RefractiveIndex::XML.getValue("config:analysis_NUM_RUN:NUM_RUN_diffnoise", NUMBER_RUNS);
|
||||
cout << "NUM_RUN DiffNoiseAnalysis " << NUM_RUN << endl;
|
||||
//NUM_RUN = 5;
|
||||
@@ -53,22 +45,50 @@ 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();
|
||||
|
||||
algo = RefractiveIndex::XML.getValue("config:algorithms:diffnoise:algo", algo_default);
|
||||
scale = RefractiveIndex::XML.getValue("config:algorithms:diffnoise:scale", scale_default);
|
||||
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);
|
||||
point_size = RefractiveIndex::XML.getValue("config:algorithms:diffnoise:point_size", point_size_default);
|
||||
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);
|
||||
|
||||
}
|
||||
|
||||
@@ -104,27 +124,79 @@ void DiffNoiseAnalysis::acquire()
|
||||
void DiffNoiseAnalysis::synthesise()
|
||||
{
|
||||
|
||||
// we don't need to synthesise
|
||||
return;
|
||||
//cout << "DiffNoiseAnalysis::saving synthesis...\n";
|
||||
if(_state == STATE_STOP) return;
|
||||
|
||||
/*
|
||||
for(float i=1;i<_saved_filenames_analysis.size()-1;i++){
|
||||
|
||||
//cout << "IResponseAnalysis::saving synthesis...\n";
|
||||
if(_state == STATE_STOP) return;
|
||||
//cout << "DiffNoiseAnalysis::synthesis FOR LOOP...\n";
|
||||
|
||||
_RUN_DONE = false;
|
||||
//cout << "_saved_filenames_analysis[i]" << _saved_filenames_analysis[i] << endl;
|
||||
|
||||
// _saved_filenames_synthesis has processed all the files in the analysis images folder
|
||||
while(!_RUN_DONE && _state != STATE_STOP)
|
||||
Thread::sleep(3);
|
||||
*/
|
||||
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.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_analysis.size();i++){
|
||||
for(float i=1;i<_saved_filenames_synthesis.size();i++){
|
||||
|
||||
if(_state == STATE_STOP) return;
|
||||
|
||||
@@ -135,21 +207,20 @@ void DiffNoiseAnalysis::displayresults()
|
||||
//cout << "!_image_shown" << endl;
|
||||
}
|
||||
|
||||
_show_image = false;
|
||||
|
||||
|
||||
if(!image1.loadImage(_saved_filenames_analysis[i])){
|
||||
if(!image3.loadImage(_saved_filenames_synthesis[i])){
|
||||
//couldn't load image
|
||||
cout << "didn't load image" << endl;
|
||||
}
|
||||
|
||||
if(image1.loadImage(_saved_filenames_analysis[i])){
|
||||
if(image3.loadImage(_saved_filenames_synthesis[i])){
|
||||
image3.loadImage(_saved_filenames_synthesis[i]);
|
||||
//cout << "_show_image = true;" << endl;
|
||||
_show_image = true;
|
||||
_image_shown = false;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
}
|
||||
|
||||
|
||||
@@ -319,6 +390,9 @@ void DiffNoiseAnalysis::draw()
|
||||
|
||||
case STATE_DISPLAY_RESULTS:
|
||||
{
|
||||
//cout << "STATE_DISPLAY_RESULTS...\n" << endl;
|
||||
|
||||
|
||||
if (_frame_cnt > 2)
|
||||
{
|
||||
_image_shown = true;
|
||||
@@ -327,47 +401,22 @@ 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;
|
||||
|
||||
image2.bind();
|
||||
ofEnableAlphaBlending();
|
||||
|
||||
RefractiveIndex::_shader.begin();
|
||||
ofSetColor(255, 255, 255);
|
||||
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());
|
||||
|
||||
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;
|
||||
ofDisableAlphaBlending();
|
||||
}
|
||||
|
||||
RefractiveIndex::_shader.end();
|
||||
|
||||
image2.unbind();
|
||||
|
||||
RefractiveIndex::cam.end();
|
||||
|
||||
// display results of the synthesis
|
||||
_RUN_DONE = true;
|
||||
break;
|
||||
|
||||
}
|
||||
|
||||
+23
-6
@@ -36,14 +36,31 @@ 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;
|
||||
|
||||
int algo;
|
||||
int scale;
|
||||
int draw_style;
|
||||
float line_width;
|
||||
float point_size;
|
||||
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;
|
||||
|
||||
};
|
||||
|
||||
+120
-67
@@ -13,17 +13,8 @@ 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);
|
||||
|
||||
NUM_RUN = RefractiveIndex::XML.getValue("config:analysis_NUM_RUN:NUM_RUN_iresponse", NUMBER_RUNS);
|
||||
cout << "NUM_RUN IResponseAnalysis " << NUM_RUN << endl;
|
||||
//NUM_RUN = 5;
|
||||
@@ -54,22 +45,51 @@ 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);
|
||||
}
|
||||
|
||||
|
||||
@@ -104,27 +124,86 @@ void IResponseAnalysis::acquire()
|
||||
void IResponseAnalysis::synthesise()
|
||||
{
|
||||
|
||||
// we don't need to synthesise
|
||||
return;
|
||||
//cout << "IResponseAnalysis::saving synthesis...\n";
|
||||
if(_state == STATE_STOP) return;
|
||||
|
||||
/*
|
||||
for(float i=1;i<_saved_filenames_analysis.size()-1;i++){
|
||||
|
||||
//cout << "IResponseAnalysis::saving synthesis...\n";
|
||||
if(_state == STATE_STOP) return;
|
||||
//cout << "IResponseAnalysis::synthesis FOR LOOP...\n";
|
||||
|
||||
_RUN_DONE = false;
|
||||
//cout << "_saved_filenames_analysis[i]" << _saved_filenames_analysis[i] << endl;
|
||||
|
||||
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_analysis.size();i++){
|
||||
for(float i=1;i<_saved_filenames_synthesis.size();i++){
|
||||
|
||||
if(_state == STATE_STOP) return;
|
||||
|
||||
@@ -135,15 +214,13 @@ void IResponseAnalysis::displayresults()
|
||||
//cout << "!_image_shown" << endl;
|
||||
}
|
||||
|
||||
_show_image = false;
|
||||
|
||||
|
||||
if(!image1.loadImage(_saved_filenames_analysis[i])){
|
||||
if(!image3.loadImage(_saved_filenames_synthesis[i])){
|
||||
//couldn't load image
|
||||
cout << "didn't load image" << endl;
|
||||
// cout << "didn't load image" << endl;
|
||||
}
|
||||
|
||||
if(image1.loadImage(_saved_filenames_analysis[i])){
|
||||
if(image3.loadImage(_saved_filenames_synthesis[i])){
|
||||
image3.loadImage(_saved_filenames_synthesis[i]);
|
||||
//cout << "_show_image = true;" << endl;
|
||||
_show_image = true;
|
||||
_image_shown = false;
|
||||
@@ -284,6 +361,8 @@ void IResponseAnalysis::draw()
|
||||
|
||||
case STATE_DISPLAY_RESULTS:
|
||||
{
|
||||
//cout << "STATE_DISPLAY_RESULTS...\n" << endl;
|
||||
|
||||
if (_frame_cnt > 2)
|
||||
{
|
||||
_image_shown = true;
|
||||
@@ -292,47 +371,21 @@ 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;
|
||||
|
||||
image2.bind();
|
||||
ofEnableAlphaBlending();
|
||||
|
||||
RefractiveIndex::_shader.begin();
|
||||
ofSetColor(255, 255, 255);
|
||||
image2.setFromPixels(image3.getPixels(),image3.width,image3.height, OF_IMAGE_COLOR);
|
||||
image2.draw(0,0, ofGetWidth(), ofGetHeight());
|
||||
|
||||
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;
|
||||
ofDisableAlphaBlending();
|
||||
}
|
||||
|
||||
RefractiveIndex::_shader.end();
|
||||
|
||||
image2.unbind();
|
||||
|
||||
RefractiveIndex::cam.end();
|
||||
|
||||
// display results of the synthesis
|
||||
_RUN_DONE = true;
|
||||
break;
|
||||
|
||||
}
|
||||
|
||||
+23
-6
@@ -35,14 +35,31 @@ 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;
|
||||
|
||||
int algo;
|
||||
int scale;
|
||||
int draw_style;
|
||||
float line_width;
|
||||
float point_size;
|
||||
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;
|
||||
|
||||
};
|
||||
|
||||
+96
-80
@@ -12,17 +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 int line_width_default = 0.5f;
|
||||
const float point_size_default = 0.5f;
|
||||
#define THRESHOLD 80
|
||||
#define MAXBLOBS 15
|
||||
|
||||
void RelaxRateAnalysis::setup(int camWidth, int camHeight)
|
||||
{
|
||||
AbstractAnalysis::setup(camWidth, camHeight);
|
||||
|
||||
NUM_RUN = RefractiveIndex::XML.getValue("config:analysis_NUM_RUN:NUM_RUN_relaxrate", NUMBER_RUNS);
|
||||
cout << "NUM_RUN RelaxRateAnalysis " << NUM_RUN << endl;
|
||||
//NUM_RUN = 5;
|
||||
@@ -31,6 +25,15 @@ 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;
|
||||
|
||||
_threshold = RefractiveIndex::XML.getValue("config:relaxrate:threshold", THRESHOLD);
|
||||
cout << "THRESHOLD RelaxRateAnalysis " << _threshold << 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
|
||||
|
||||
@@ -52,23 +55,17 @@ 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();
|
||||
|
||||
////---------
|
||||
|
||||
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);
|
||||
cvColorImage1.allocate(RefractiveIndex::_vid_w,RefractiveIndex::_vid_h);
|
||||
cvGrayDiff1.allocate(RefractiveIndex::_vid_w,RefractiveIndex::_vid_h);
|
||||
|
||||
}
|
||||
|
||||
@@ -102,53 +99,77 @@ void RelaxRateAnalysis::acquire()
|
||||
|
||||
void RelaxRateAnalysis::synthesise()
|
||||
{
|
||||
// we don't need to synthesise
|
||||
return;
|
||||
|
||||
/*
|
||||
|
||||
//cout << "IResponseAnalysis::saving synthesis...\n";
|
||||
if(_state == STATE_STOP) return;
|
||||
|
||||
_RUN_DONE = false;
|
||||
cvContourFinderVect.clear();
|
||||
|
||||
|
||||
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(_threshold);
|
||||
|
||||
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()
|
||||
{
|
||||
|
||||
for(float i=1;i<_saved_filenames_analysis.size();i++){
|
||||
//cvContourFinderVectDisplay.clear();
|
||||
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;
|
||||
}
|
||||
|
||||
_show_image = false;
|
||||
cvContourFinderVectDisplay.push_back(cvContourFinderVect[i]);
|
||||
_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();
|
||||
|
||||
|
||||
}
|
||||
|
||||
|
||||
@@ -289,47 +310,16 @@ void RelaxRateAnalysis::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);
|
||||
{
|
||||
for(int i=0;i<cvContourFinderVectDisplay.size();i++){
|
||||
cvContourFinderVectDisplay[i]->draw(0,0, ofGetWidth(), ofGetHeight());
|
||||
}
|
||||
|
||||
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();
|
||||
|
||||
// display results of the synthesis
|
||||
_RUN_DONE = true;
|
||||
break;
|
||||
|
||||
}
|
||||
@@ -348,5 +338,31 @@ 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();
|
||||
}
|
||||
|
||||
|
||||
@@ -23,6 +23,7 @@ public:
|
||||
void acquire();
|
||||
void synthesise();
|
||||
void displayresults();
|
||||
void cleanup();
|
||||
|
||||
void draw();
|
||||
|
||||
@@ -30,24 +31,24 @@ public:
|
||||
|
||||
protected:
|
||||
|
||||
void clearcfindervect();
|
||||
void clearcfindervectdisplay();
|
||||
|
||||
bool _RUN_DONE;
|
||||
float _flip, _level;
|
||||
int _run_cnt, _save_cnt, _synth_save_cnt, _anim_cnt;
|
||||
float c, _frame_cnt, _frame_cnt_max, _anim_cnt_max;
|
||||
|
||||
int _treshold;
|
||||
int _threshold;
|
||||
int _maxblobs;
|
||||
|
||||
bool _show_image, _image_shown;
|
||||
|
||||
ofImage image1;
|
||||
ofImage image2;
|
||||
ofImage image1;
|
||||
ofxCvColorImage cvColorImage1;
|
||||
ofxCvGrayscaleImage cvGrayDiff1;
|
||||
|
||||
int algo;
|
||||
int scale;
|
||||
int draw_style;
|
||||
float line_width;
|
||||
float point_size;
|
||||
vector<rfiCvContourFinder*> cvContourFinderVect;
|
||||
vector<rfiCvContourFinder*> cvContourFinderVectDisplay;
|
||||
|
||||
};
|
||||
|
||||
+141
-73
@@ -17,15 +17,8 @@ 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);
|
||||
|
||||
NUM_RUN = RefractiveIndex::XML.getValue("config:analysis_NUM_RUN:NUM_RUN_shadowscapes", NUMBER_RUNS);
|
||||
cout << "NUM_RUN ShadowScapesAnalysis " << NUM_RUN << endl;
|
||||
//NUM_RUN = 5;
|
||||
@@ -47,7 +40,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 = 300.0;
|
||||
_scanLineWidth = 100.0;
|
||||
_run_cnt = 0;
|
||||
_save_cnt = 0;
|
||||
_synth_save_cnt = 0;
|
||||
@@ -60,21 +53,50 @@ 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();
|
||||
|
||||
algo = RefractiveIndex::XML.getValue("config:algorithms:shadowscapes:algo", algo_default);
|
||||
scale = RefractiveIndex::XML.getValue("config:algorithms:shadowscapes:scale", scale_default);
|
||||
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);
|
||||
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);
|
||||
|
||||
}
|
||||
|
||||
@@ -102,50 +124,116 @@ void ShadowScapesAnalysis::acquire()
|
||||
|
||||
void ShadowScapesAnalysis::synthesise()
|
||||
{
|
||||
// we don't need to synthesise
|
||||
return;
|
||||
//cout << "ShadowScapesAnalysis::saving synthesis...\n";
|
||||
|
||||
/*
|
||||
for(float i=1;i<_saved_filenames_analysis.size()-1; i++){
|
||||
|
||||
//cout << "IResponseAnalysis::saving synthesis...\n";
|
||||
if(_state == STATE_STOP) return;
|
||||
// cout << "ShadowScapesAnalysis::synthesis FOR LOOP...\n";
|
||||
|
||||
_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++){
|
||||
// cout << "_saved_filenames_analysis[i]" << _saved_filenames_analysis[i] << endl;
|
||||
|
||||
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;
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
|
||||
@@ -333,47 +421,27 @@ 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;
|
||||
|
||||
image2.bind();
|
||||
ofEnableAlphaBlending();
|
||||
|
||||
RefractiveIndex::_shader.begin();
|
||||
ofSetColor(255, 255, 255);
|
||||
|
||||
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;
|
||||
}
|
||||
|
||||
RefractiveIndex::_shader.end();
|
||||
|
||||
image2.unbind();
|
||||
|
||||
RefractiveIndex::cam.end();
|
||||
|
||||
// display results of the synthesis
|
||||
_RUN_DONE = true;
|
||||
|
||||
// clear allocated memory...?
|
||||
|
||||
break;
|
||||
}
|
||||
|
||||
|
||||
@@ -42,13 +42,31 @@ 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;
|
||||
|
||||
int algo;
|
||||
int scale;
|
||||
int draw_style;
|
||||
double line_width;
|
||||
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;
|
||||
|
||||
};
|
||||
@@ -13,17 +13,8 @@ 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);
|
||||
|
||||
NUM_RUN = RefractiveIndex::XML.getValue("config:analysis_NUM_RUN:NUM_RUN_shapefromshading", NUMBER_RUNS);
|
||||
cout << "NUM_RUN ShapeFromShadingAnalysis " << NUM_RUN << endl;
|
||||
//NUM_RUN = 5;
|
||||
@@ -54,21 +45,50 @@ void ShapeFromShadingAnalysis::setup(int camWidth, int camHeight)
|
||||
|
||||
image1.clear();
|
||||
image2.clear();
|
||||
image3.clear();
|
||||
image4.clear();
|
||||
image5.clear();
|
||||
|
||||
image1.setUseTexture(false);
|
||||
image2.setUseTexture(true);
|
||||
// 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;
|
||||
|
||||
algo = RefractiveIndex::XML.getValue("config:algorithms:shapeshade:algo", algo_default);
|
||||
scale = RefractiveIndex::XML.getValue("config:algorithms:shapeshade:scale", scale_default);
|
||||
draw_style = RefractiveIndex::XML.getValue("config:algorithms:shapeshade:draw_style", draw_style_default);
|
||||
line_width = RefractiveIndex::XML.getValue("config:algorithms:shapeshade:line_width", line_width_default);
|
||||
point_size = RefractiveIndex::XML.getValue("config:algorithms:shapeshade:point_size", point_size_default);
|
||||
// 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);
|
||||
|
||||
}
|
||||
|
||||
@@ -124,46 +144,99 @@ void ShapeFromShadingAnalysis::acquire()
|
||||
|
||||
void ShapeFromShadingAnalysis::synthesise()
|
||||
{
|
||||
// we don't need to synthesise
|
||||
return;
|
||||
// cout << "ShapeFromShadingAnalysis::saving synthesis...\n";
|
||||
if(_state == STATE_STOP) return;
|
||||
|
||||
/*
|
||||
for(float i=1;i<_saved_filenames_analysis.size()-1;i++){
|
||||
|
||||
//cout << "IResponseAnalysis::saving synthesis...\n";
|
||||
if(_state == STATE_STOP) return;
|
||||
// cout << "ShapeFromShadingAnalysis::synthesis FOR LOOP...\n";
|
||||
|
||||
_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++){
|
||||
// cout << "_saved_filenames_analysis[i]" << _saved_filenames_analysis[i] << endl;
|
||||
|
||||
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;
|
||||
@@ -477,6 +550,8 @@ void ShapeFromShadingAnalysis::draw()
|
||||
|
||||
case STATE_DISPLAY_RESULTS:
|
||||
{
|
||||
// cout << "STATE_DISPLAY_RESULTS...\n" << endl;
|
||||
|
||||
if (_frame_cnt > 2)
|
||||
{
|
||||
_image_shown = true;
|
||||
@@ -485,50 +560,23 @@ 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;
|
||||
|
||||
image2.bind();
|
||||
ofEnableAlphaBlending();
|
||||
|
||||
RefractiveIndex::_shader.begin();
|
||||
ofSetColor(255, 255, 255);
|
||||
image2.setFromPixels(image3.getPixels(),image3.width,image3.height, OF_IMAGE_COLOR);
|
||||
image2.draw(0,0, ofGetWidth(), ofGetHeight());
|
||||
|
||||
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;
|
||||
ofDisableAlphaBlending();
|
||||
}
|
||||
|
||||
RefractiveIndex::_shader.end();
|
||||
|
||||
image2.unbind();
|
||||
|
||||
RefractiveIndex::cam.end();
|
||||
|
||||
// display results of the synthesis
|
||||
_RUN_DONE = true;
|
||||
break;
|
||||
|
||||
|
||||
}
|
||||
|
||||
|
||||
|
||||
@@ -55,14 +55,31 @@ 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;
|
||||
|
||||
int algo;
|
||||
int scale;
|
||||
int draw_style;
|
||||
float line_width;
|
||||
float point_size;
|
||||
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;
|
||||
|
||||
};
|
||||
|
||||
+118
-69
@@ -13,16 +13,8 @@ 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);
|
||||
|
||||
NUM_RUN = RefractiveIndex::XML.getValue("config:analysis_NUM_RUN:NUM_RUN_strobe", NUMBER_RUNS);
|
||||
cout << "NUM_RUN StrobeAnalysis " << NUM_RUN << endl;
|
||||
//NUM_RUN = 5;
|
||||
@@ -54,24 +46,50 @@ void StrobeAnalysis::setup(int camWidth, int camHeight)
|
||||
|
||||
image1.clear();
|
||||
image2.clear();
|
||||
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();
|
||||
|
||||
algo = RefractiveIndex::XML.getValue("config:algorithms:strobe:algo", algo_default);
|
||||
scale = RefractiveIndex::XML.getValue("config:algorithms:strobe:scale", scale_default);
|
||||
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);
|
||||
point_size = RefractiveIndex::XML.getValue("config:algorithms:strobe:point_size", point_size_default);
|
||||
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);
|
||||
|
||||
}
|
||||
|
||||
@@ -108,45 +126,100 @@ void StrobeAnalysis::acquire()
|
||||
|
||||
void StrobeAnalysis::synthesise()
|
||||
{
|
||||
// we don't need to synthesise
|
||||
return;
|
||||
// cout << "StrobeAnalysis::saving synthesis...\n";
|
||||
if(_state == STATE_STOP) return;
|
||||
|
||||
/*
|
||||
for(float i=1;i<_saved_filenames_analysis.size()-1;i++){
|
||||
|
||||
//cout << "IResponseAnalysis::saving synthesis...\n";
|
||||
if(_state == STATE_STOP) return;
|
||||
// cout << "StrobeAnalysis::synthesis FOR LOOP...\n";
|
||||
|
||||
_RUN_DONE = false;
|
||||
// cout << "_saved_filenames_analysis[i]" << _saved_filenames_analysis[i] << endl;
|
||||
|
||||
// _saved_filenames_synthesis has processed all the files in the analysis images folder
|
||||
while(!_RUN_DONE && _state != STATE_STOP)
|
||||
Thread::sleep(3);
|
||||
*/
|
||||
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.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_analysis.size();i++){
|
||||
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;
|
||||
// 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])){
|
||||
if(!image3.loadImage(_saved_filenames_synthesis[i])){
|
||||
//couldn't load image
|
||||
cout << "didn't load image" << endl;
|
||||
// cout << "didn't load image" << endl;
|
||||
}
|
||||
|
||||
if(image1.loadImage(_saved_filenames_analysis[i])){
|
||||
if(image3.loadImage(_saved_filenames_synthesis[i])){
|
||||
image3.loadImage(_saved_filenames_synthesis[i]);
|
||||
//cout << "_show_image = true;" << endl;
|
||||
_show_image = true;
|
||||
_image_shown = false;
|
||||
@@ -306,6 +379,8 @@ void StrobeAnalysis::draw()
|
||||
case STATE_DISPLAY_RESULTS:
|
||||
{
|
||||
|
||||
// cout << "STATE_DISPLAY_RESULTS...\n" << endl;
|
||||
|
||||
if (_frame_cnt > 2)
|
||||
{
|
||||
_image_shown = true;
|
||||
@@ -314,47 +389,21 @@ 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;
|
||||
|
||||
image2.bind();
|
||||
ofEnableAlphaBlending();
|
||||
|
||||
RefractiveIndex::_shader.begin();
|
||||
ofSetColor(255, 255, 255);
|
||||
image2.setFromPixels(image3.getPixels(),image3.width,image3.height, OF_IMAGE_COLOR);
|
||||
image2.draw(0,0, ofGetWidth(), ofGetHeight());
|
||||
|
||||
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;
|
||||
ofDisableAlphaBlending();
|
||||
}
|
||||
|
||||
RefractiveIndex::_shader.end();
|
||||
|
||||
image2.unbind();
|
||||
|
||||
RefractiveIndex::cam.end();
|
||||
|
||||
// display results of the synthesis
|
||||
_RUN_DONE = true;
|
||||
break;
|
||||
|
||||
|
||||
|
||||
+23
-6
@@ -41,14 +41,31 @@ 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;
|
||||
|
||||
int algo;
|
||||
int scale;
|
||||
int draw_style;
|
||||
float line_width;
|
||||
float point_size;
|
||||
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;
|
||||
|
||||
};
|
||||
|
||||
Reference in New Issue
Block a user