Compare commits
4 Commits
| Author | SHA1 | Date | |
|---|---|---|---|
 Tom Schofield
|
8b9c3eaebc | ||
|
Tom Schofield
|
a9c8a56850 | ||
|
Tom Schofield
|
706eb9354d | ||
|
Tom Schofield
|
21791b9769 |
@@ -1 +1,8 @@
|
||||
|
||||
src/.DS_Store
|
||||
.DS_Store
|
||||
Project.xcconfig
|
||||
bin/
|
||||
openFrameworks-Info.plist
|
||||
opencvExample.xcodeproj/
|
||||
config.refindx
|
||||
-115
@@ -1,115 +0,0 @@
|
||||
<!-- 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>
|
||||
|
||||
<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_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>
|
||||
|
||||
<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>
|
||||
|
||||
</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;
|
||||
|
||||
|
||||
}
|
||||
+131
-96
@@ -15,16 +15,11 @@
|
||||
|
||||
#include "ofxXmlSettings.h"
|
||||
|
||||
#include "ofxArcBall.h"
|
||||
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
|
||||
#define CAMERA_ID 0
|
||||
#define CAMERA_ACQU_WIDTH 640
|
||||
#define CAMERA_ACQU_HEIGHT 480
|
||||
|
||||
#define LOCATION "MIDDLESBOROUGH"
|
||||
#define LOCATION "MANCHESTER"
|
||||
|
||||
#define ISTATE_UNDEF 0xEEEE
|
||||
#define ISTATE_START 0xAAAA
|
||||
@@ -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,11 @@ 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();
|
||||
camDist=1000;
|
||||
|
||||
//camera.setOrientation(ofVec3f(1,-1,1));
|
||||
bool save_config = false;
|
||||
|
||||
cout << "Loading configuration..." << endl;
|
||||
@@ -174,31 +100,41 @@ 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);
|
||||
|
||||
}
|
||||
|
||||
@@ -215,6 +151,16 @@ void RefractiveIndex::start_analysis()
|
||||
_analysisAdapator = new AnalysisAdaptor(_currentAnalysis);
|
||||
_currentAnalysis->setup(_vid_w, _vid_h);
|
||||
_analysisAdapator->start();
|
||||
|
||||
|
||||
//allocate fbo for HD
|
||||
fbo.allocate(1920,1080);
|
||||
|
||||
// fbo.allocate( _currentAnalysis->_mesh_size_multiplier *_vid_w,_currentAnalysis->_mesh_size_multiplier * _vid_h);
|
||||
camera.setPosition(fbo.getWidth()/2, fbo.getHeight()/2,_currentAnalysis->_mesh_size_multiplier *500);
|
||||
_meshRotation=0;
|
||||
|
||||
|
||||
}
|
||||
|
||||
void RefractiveIndex::stop_analysis()
|
||||
@@ -240,6 +186,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,11 +218,52 @@ 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);
|
||||
|
||||
if(_currentAnalysis)
|
||||
if(_currentAnalysis){
|
||||
_currentAnalysis->draw();
|
||||
|
||||
|
||||
if(_currentAnalysis->meshIsComplete){
|
||||
|
||||
fbo.begin();
|
||||
glShadeModel(GL_SMOOTH);
|
||||
ofClear(0,0,0);
|
||||
|
||||
camera.begin();
|
||||
ofSetColor(0, 0, 0);
|
||||
//this is a hack, I don't know how to colour the fbo with black pixels so I'm drawing a massive black rectangle in the background
|
||||
ofPushMatrix();
|
||||
ofTranslate(0, 0,-500);
|
||||
ofRect(-fbo.getWidth(), -fbo.getHeight(), fbo.getWidth()*3, fbo.getHeight()*3);
|
||||
|
||||
|
||||
ofPopMatrix();
|
||||
ofSetColor(255);
|
||||
|
||||
float xDiff= (fbo.getWidth()- (_currentAnalysis->_mesh_size_multiplier *_vid_w))/2;
|
||||
float yDiff= (fbo.getHeight()- (_currentAnalysis->_mesh_size_multiplier *_vid_h))/2;
|
||||
|
||||
|
||||
ofTranslate(xDiff,yDiff,-_currentAnalysis->zPlaneAverage );
|
||||
_currentAnalysis->aMesh.draw();
|
||||
|
||||
camera.end();
|
||||
fbo.end();
|
||||
|
||||
ofPixels pixels;
|
||||
fbo.readToPixels(pixels);
|
||||
|
||||
ofSaveImage(pixels,_currentAnalysis->meshFileName, OF_IMAGE_QUALITY_BEST);
|
||||
//saving jpgs doesn't work - pngs only!
|
||||
|
||||
}
|
||||
|
||||
}
|
||||
}
|
||||
|
||||
void RefractiveIndex::setup_camera()
|
||||
@@ -309,10 +297,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 +413,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()
|
||||
|
||||
@@ -10,16 +10,12 @@
|
||||
|
||||
#include "ofxOpenCv.h"
|
||||
#include "ofxXmlSettings.h"
|
||||
#include "ofxOpenCv.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 +34,6 @@ public:
|
||||
void stop_analysis();
|
||||
void state_analysis();
|
||||
|
||||
void setup_shader_vbo();
|
||||
|
||||
// ofx
|
||||
void keyPressed (int key);
|
||||
void keyReleased(int key){;}
|
||||
@@ -62,6 +56,9 @@ protected:
|
||||
AnalysisAdaptor* _analysisAdapator;
|
||||
vector<AbstractAnalysis*> _analysisVector;
|
||||
|
||||
float _meshRotation;
|
||||
float camDist;
|
||||
ofEasyCam cam;
|
||||
public:
|
||||
// acquisition
|
||||
static ofPixels _pixels;
|
||||
@@ -76,17 +73,8 @@ public:
|
||||
// this should be in xml
|
||||
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;
|
||||
|
||||
|
||||
ofCamera camera;
|
||||
ofPixels keepOnScreen;
|
||||
ofFbo fbo;
|
||||
ofLight light;
|
||||
};
|
||||
@@ -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());
|
||||
|
||||
}
|
||||
|
||||
+11
-19
@@ -7,8 +7,10 @@
|
||||
|
||||
void AbstractAnalysis::setup(int camWidth, int camHeight) {
|
||||
|
||||
_cam_w = camWidth; _cam_h = camHeight;
|
||||
meshIsComplete=false;
|
||||
imageForContourAvailable=false;
|
||||
|
||||
_cam_w = camWidth; _cam_h = camHeight;
|
||||
if(RefractiveIndex::_mode == MODE_DRAWING) {
|
||||
ofFileDialogResult r = ofSystemLoadDialog("choooose da folda", true);
|
||||
if(!r.bSuccess) {
|
||||
@@ -20,16 +22,6 @@ void AbstractAnalysis::setup(int camWidth, int camHeight) {
|
||||
_whole_file_path_synthesis = r.filePath + "/darwings";
|
||||
}
|
||||
|
||||
// viewport
|
||||
|
||||
tx = RefractiveIndex::XML.getValue("config:viewport:tx", 200.0);
|
||||
ty = RefractiveIndex::XML.getValue("config:viewport:ty", 50.0);
|
||||
tz = RefractiveIndex::XML.getValue("config:viewport:tz", -500.0);
|
||||
|
||||
rx = RefractiveIndex::XML.getValue("config:viewport:rx", 0.0);
|
||||
ry = RefractiveIndex::XML.getValue("config:viewport:ry", 0.0);
|
||||
rz = RefractiveIndex::XML.getValue("config:viewport:rz", 0.0);
|
||||
|
||||
}
|
||||
|
||||
// this is the main threaded loop for a given analysis
|
||||
@@ -54,13 +46,14 @@ void AbstractAnalysis::do_synthesize() {
|
||||
if(_state == STATE_STOP) goto exit;
|
||||
_state = STATE_DISPLAY_RESULTS;
|
||||
displayresults();
|
||||
cleanup();
|
||||
}
|
||||
|
||||
break;
|
||||
}
|
||||
|
||||
case MODE_DRAWING:
|
||||
{
|
||||
|
||||
|
||||
ofxFileHelper fileHelperDrawing;
|
||||
if(!fileHelperDrawing.doesDirectoryExist(_whole_file_path_synthesis)){
|
||||
fileHelperDrawing.makeDirectory(_whole_file_path_synthesis);
|
||||
@@ -72,14 +65,12 @@ void AbstractAnalysis::do_synthesize() {
|
||||
if(_state == STATE_STOP) goto exit;
|
||||
_state = STATE_DISPLAY_RESULTS;
|
||||
displayresults();
|
||||
|
||||
break;
|
||||
cleanup();
|
||||
}
|
||||
}
|
||||
|
||||
exit:
|
||||
cleanup();
|
||||
ofxFileHelper::deleteFolder(_whole_file_path_analysis);
|
||||
ofNotifyEvent(_synthesize_cb, _name);
|
||||
|
||||
}
|
||||
@@ -131,7 +122,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 +139,6 @@ void AbstractAnalysis::create_dir_allocate_images()
|
||||
fileHelperSynthesis.makeDirectory(SYNTHESIS_PATH+RefractiveIndex::_location+"/"+_name+"/"+replaceTime);
|
||||
|
||||
}
|
||||
|
||||
//////////////////////////////END DIRECTORY CREATION //////////////////////////////////////////////////
|
||||
|
||||
|
||||
@@ -168,6 +157,7 @@ void AbstractAnalysis::create_dir_allocate_images()
|
||||
myGrayImage1.setUseTexture(false);
|
||||
myGrayImage1.allocate(RefractiveIndex::_vid_w, RefractiveIndex::_vid_h, OF_IMAGE_GRAYSCALE);
|
||||
|
||||
|
||||
//////////////////////////////END ALLOCATE IMAGES //////////////////////////////////////////////////
|
||||
|
||||
}
|
||||
@@ -192,6 +182,9 @@ void AbstractAnalysis::read_dir_create_list(string folder_path)
|
||||
for(int i = 0; i < list.size(); i++) {
|
||||
string filepath = folder_path + "/" + list[i];
|
||||
_saved_filenames_analysis.push_back(filepath);
|
||||
|
||||
cout << list[i] << endl;
|
||||
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -204,7 +197,6 @@ void AbstractAnalysis::saveImageAnalysis(string filename)
|
||||
if (RefractiveIndex::_vidGrabber.isFrameNew())
|
||||
{
|
||||
RefractiveIndex::_pixels = RefractiveIndex::_vidGrabber.getPixelsRef(); //get ofPixels from the camera
|
||||
|
||||
} else {
|
||||
return;
|
||||
}
|
||||
|
||||
+14
-4
@@ -61,6 +61,20 @@ public:
|
||||
|
||||
// event
|
||||
ofEvent<string> _synthesize_cb;
|
||||
bool meshIsComplete;
|
||||
bool imageForContourAvailable;
|
||||
ofMesh aMesh;
|
||||
string meshFileName;
|
||||
//difference between our image size and the size of the fbo
|
||||
float widthScaleFactor;
|
||||
float heightScaleFactor;
|
||||
ofImage contourImage;
|
||||
ofPixels meshPix;
|
||||
ofPixels publicColorImage;
|
||||
float zPlaneAverage;
|
||||
|
||||
//added Tom 1/5/12 defines the stretch we make to the mesh to make it fit HD proportions
|
||||
float _mesh_size_multiplier;
|
||||
|
||||
protected:
|
||||
int _cam_w, _cam_h;
|
||||
@@ -81,9 +95,5 @@ protected:
|
||||
int NUM_RUN;
|
||||
int NUM_SAVE_PER_RUN;
|
||||
|
||||
//viewport
|
||||
|
||||
float tx, ty, tz, rx, ry, rz;
|
||||
|
||||
friend class AnalysisAdaptor;
|
||||
};
|
||||
+122
-65
@@ -13,13 +13,6 @@ 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);
|
||||
@@ -54,25 +47,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 +127,90 @@ void CamNoiseAnalysis::acquire()
|
||||
|
||||
void CamNoiseAnalysis::synthesise()
|
||||
{
|
||||
// we don't need to synthesise
|
||||
return;
|
||||
|
||||
/*
|
||||
|
||||
//cout << "IResponseAnalysis::saving synthesis...\n";
|
||||
//cout << "CamNoiseAnalysis::saving synthesis...\n";
|
||||
if(_state == STATE_STOP) return;
|
||||
|
||||
_RUN_DONE = false;
|
||||
for(float i=1;i<_saved_filenames_analysis.size()-1;i++){
|
||||
|
||||
//cout << "CamNoiseAnalysis::synthesis FOR LOOP...\n";
|
||||
|
||||
//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);
|
||||
//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 +221,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 +389,8 @@ void CamNoiseAnalysis::draw()
|
||||
case STATE_DISPLAY_RESULTS:
|
||||
{
|
||||
|
||||
//cout << "STATE_DISPLAY_RESULTS...\n" << endl;
|
||||
|
||||
if (_frame_cnt > 2)
|
||||
{
|
||||
_image_shown = true;
|
||||
@@ -316,47 +399,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;
|
||||
};
|
||||
|
||||
+110
-60
@@ -12,11 +12,6 @@ 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);
|
||||
@@ -51,21 +46,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 +125,79 @@ void ColorMultiAnalysis::acquire()
|
||||
void ColorMultiAnalysis::synthesise()
|
||||
{
|
||||
|
||||
// we don't need to synthesise
|
||||
return;
|
||||
|
||||
/*
|
||||
|
||||
//cout << "IResponseAnalysis::saving synthesis...\n";
|
||||
//cout << "ColorMultiAnalysis::saving synthesis...\n";
|
||||
if(_state == STATE_STOP) return;
|
||||
|
||||
_RUN_DONE = false;
|
||||
for(float i=1;i<_saved_filenames_analysis.size()-1;i++){
|
||||
|
||||
//cout << "ColorMultiAnalysis::synthesis FOR LOOP...\n";
|
||||
|
||||
//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.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 +208,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;
|
||||
@@ -280,9 +356,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 +371,7 @@ void ColorMultiAnalysis::draw()
|
||||
|
||||
//cout << "STATE_DISPLAY_RESULTS...\n" << endl;
|
||||
|
||||
|
||||
if (_frame_cnt > 2)
|
||||
{
|
||||
_image_shown = true;
|
||||
@@ -304,46 +380,20 @@ void ColorMultiAnalysis::draw()
|
||||
|
||||
_frame_cnt++;
|
||||
|
||||
if (_show_image)
|
||||
{
|
||||
//cout << "_show_image...\n" << endl;
|
||||
|
||||
ofEnableAlphaBlending();
|
||||
glShadeModel(GL_SMOOTH);
|
||||
glLineWidth(line_width);
|
||||
|
||||
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);
|
||||
|
||||
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;
|
||||
ofDisableAlphaBlending();
|
||||
}
|
||||
|
||||
RefractiveIndex::_shader.end();
|
||||
|
||||
image2.unbind();
|
||||
|
||||
RefractiveIndex::cam.end();
|
||||
|
||||
// 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;
|
||||
|
||||
|
||||
};
|
||||
|
||||
+110
-58
@@ -13,11 +13,6 @@ 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);
|
||||
@@ -58,21 +53,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);
|
||||
|
||||
}
|
||||
|
||||
@@ -109,26 +133,81 @@ void ColorSingleAnalysis::acquire()
|
||||
void ColorSingleAnalysis::synthesise()
|
||||
{
|
||||
|
||||
// we don't need to synthesise
|
||||
return;
|
||||
|
||||
/*
|
||||
|
||||
//cout << "IResponseAnalysis::saving synthesis...\n";
|
||||
//cout << "ColorSingleAnalysis::saving synthesis...\n";
|
||||
if(_state == STATE_STOP) return;
|
||||
|
||||
_RUN_DONE = false;
|
||||
for(float i=1;i<_saved_filenames_analysis.size()-1;i++){
|
||||
|
||||
//cout << "ColorSingleAnalysis::synthesis FOR LOOP...\n";
|
||||
|
||||
//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.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++){
|
||||
for(float i=1;i<_saved_filenames_synthesis.size();i++){
|
||||
|
||||
if(_state == STATE_STOP) return;
|
||||
|
||||
@@ -139,15 +218,13 @@ 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;
|
||||
@@ -312,6 +389,7 @@ void ColorSingleAnalysis::draw()
|
||||
|
||||
//cout << "STATE_DISPLAY_RESULTS...\n" << endl;
|
||||
|
||||
|
||||
if (_frame_cnt > 2)
|
||||
{
|
||||
_image_shown = true;
|
||||
@@ -320,46 +398,20 @@ void ColorSingleAnalysis::draw()
|
||||
|
||||
_frame_cnt++;
|
||||
|
||||
if (_show_image)
|
||||
{
|
||||
//cout << "_show_image...\n" << endl;
|
||||
|
||||
ofEnableAlphaBlending();
|
||||
glShadeModel(GL_SMOOTH);
|
||||
glLineWidth(line_width);
|
||||
|
||||
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);
|
||||
|
||||
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;
|
||||
ofDisableAlphaBlending();
|
||||
}
|
||||
|
||||
RefractiveIndex::_shader.end();
|
||||
|
||||
image2.unbind();
|
||||
|
||||
RefractiveIndex::cam.end();
|
||||
|
||||
// display results of the synthesis
|
||||
_RUN_DONE = true;
|
||||
break;
|
||||
|
||||
|
||||
@@ -38,13 +38,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;
|
||||
|
||||
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;
|
||||
|
||||
};
|
||||
|
||||
+112
-61
@@ -13,12 +13,6 @@ 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);
|
||||
@@ -53,22 +47,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 +126,79 @@ void DiffNoiseAnalysis::acquire()
|
||||
void DiffNoiseAnalysis::synthesise()
|
||||
{
|
||||
|
||||
// we don't need to synthesise
|
||||
return;
|
||||
|
||||
/*
|
||||
|
||||
//cout << "IResponseAnalysis::saving synthesis...\n";
|
||||
//cout << "DiffNoiseAnalysis::saving synthesis...\n";
|
||||
if(_state == STATE_STOP) return;
|
||||
|
||||
_RUN_DONE = false;
|
||||
for(float i=1;i<_saved_filenames_analysis.size()-1;i++){
|
||||
|
||||
//cout << "DiffNoiseAnalysis::synthesis FOR LOOP...\n";
|
||||
|
||||
//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.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 +209,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 +392,9 @@ void DiffNoiseAnalysis::draw()
|
||||
|
||||
case STATE_DISPLAY_RESULTS:
|
||||
{
|
||||
//cout << "STATE_DISPLAY_RESULTS...\n" << endl;
|
||||
|
||||
|
||||
if (_frame_cnt > 2)
|
||||
{
|
||||
_image_shown = true;
|
||||
@@ -327,47 +403,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;
|
||||
|
||||
};
|
||||
|
||||
+291
-61
@@ -13,13 +13,6 @@ 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);
|
||||
@@ -32,6 +25,12 @@ void IResponseAnalysis::setup(int camWidth, int camHeight)
|
||||
acq_run_time = RefractiveIndex::XML.getValue("config:analysis_time:acquiretime_iresponse", ACQUIRE_TIME);
|
||||
cout << "ACQUIRE_TIME IResponseAnalysis " << acq_run_time << endl;
|
||||
|
||||
//flag for main sketch
|
||||
meshIsComplete=false;
|
||||
_gotFirstImage=false;
|
||||
|
||||
_mesh_size_multiplier=4;
|
||||
|
||||
|
||||
//int acq_run_time = 20; // 20 seconds of acquiring per run
|
||||
|
||||
@@ -54,22 +53,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);
|
||||
}
|
||||
|
||||
|
||||
@@ -103,28 +131,87 @@ void IResponseAnalysis::acquire()
|
||||
|
||||
void IResponseAnalysis::synthesise()
|
||||
{
|
||||
cout<<"SYNTHESISING IRESPONSE";
|
||||
|
||||
// we don't need to synthesise
|
||||
return;
|
||||
|
||||
/*
|
||||
|
||||
//cout << "IResponseAnalysis::saving synthesis...\n";
|
||||
if(_state == STATE_STOP) return;
|
||||
|
||||
_RUN_DONE = false;
|
||||
for(float i=1;i<_saved_filenames_analysis.size()-1;i++){
|
||||
|
||||
//cout << "IResponseAnalysis::synthesis FOR LOOP...\n";
|
||||
|
||||
//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 //////////////////////////
|
||||
if(!_gotFirstImage){
|
||||
cout<<"background image is"<< _saved_filenames_analysis[i]<<endl;
|
||||
_background=image1;
|
||||
_gotFirstImage=true;
|
||||
}
|
||||
|
||||
//subtract background begin///////////////
|
||||
|
||||
ofPixels imagePixels1 = image1.getPixelsRef();
|
||||
ofPixels imagePixels2 = image5.getPixelsRef();
|
||||
ofPixels backgroundPixels = _background.getPixelsRef();
|
||||
|
||||
for(int i=0;i<imagePixels1.size();i++){
|
||||
|
||||
unsigned char val=imagePixels1[i];
|
||||
// cout<<(int)backgroundPixels[i]<< " thesePixels[i] "<<(int)imagePixels1[i]<<endl;
|
||||
if(imagePixels1[i]-backgroundPixels[i]>0){
|
||||
imagePixels1[i]-=backgroundPixels[i];
|
||||
}
|
||||
else{
|
||||
imagePixels1[i]=0;
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
//update the images with their new background subtracted selves
|
||||
image1.setFromPixels(imagePixels1);
|
||||
|
||||
|
||||
//flag the main app that we aren't read yet
|
||||
meshIsComplete=false;
|
||||
//make a mesh - this mesh will be drawn in the main app
|
||||
setMeshFromPixels(_returnDepthsAtEachPixel(image1, image1, _background), image1,image1, aMesh);
|
||||
//meshPix=make3DZmap(image1, image5, _background);
|
||||
//with jpgs this was refusing to save out
|
||||
meshFileName = _whole_file_path_synthesis+"/"+ofToString(_synth_save_cnt, 2)+"_IResponseSynthesis_"+ofToString(_run_cnt,2)+".png";
|
||||
_saved_filenames_synthesis.push_back(meshFileName);
|
||||
|
||||
//flag that we are finished
|
||||
meshIsComplete=true;
|
||||
_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 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 +222,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 +369,8 @@ void IResponseAnalysis::draw()
|
||||
|
||||
case STATE_DISPLAY_RESULTS:
|
||||
{
|
||||
//cout << "STATE_DISPLAY_RESULTS...\n" << endl;
|
||||
|
||||
if (_frame_cnt > 2)
|
||||
{
|
||||
_image_shown = true;
|
||||
@@ -292,47 +379,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;
|
||||
|
||||
}
|
||||
@@ -352,3 +413,172 @@ void IResponseAnalysis::save_cb(Timer& timer)
|
||||
|
||||
saveImageAnalysis(file_name);
|
||||
}
|
||||
|
||||
void IResponseAnalysis::setMeshFromPixels(vector<float> sPixels, ofImage currentFirstImage, ofImage currentSecondImage, ofMesh & mesh){
|
||||
int x=0;
|
||||
int y=0;
|
||||
|
||||
//get rid of all previous vectors and colours
|
||||
mesh.clear();
|
||||
mesh.setMode(OF_PRIMITIVE_TRIANGLES);
|
||||
|
||||
ofColor meshColour=ofColor(255,0,0);
|
||||
|
||||
int chooseColour=1 ;
|
||||
|
||||
//the average z position of the matrix - used later to centre the mesh on the z axis when drawing
|
||||
float zPlaneAverage=0;
|
||||
|
||||
for(int i=0;i<sPixels.size();i++){
|
||||
zPlaneAverage+=sPixels[i];
|
||||
}
|
||||
if (sPixels.size()!=0) {
|
||||
zPlaneAverage/=sPixels.size();
|
||||
//cout<<zPlaneAverage<<" zPlaneAverage "<<endl;
|
||||
}
|
||||
|
||||
else{
|
||||
cout<<"DEPTH FLOAT ARRAY IS EMPTY";
|
||||
}
|
||||
|
||||
if(chooseColour==1){
|
||||
for(int i=0;i<sPixels.size();i++){
|
||||
mesh.addColor( currentSecondImage.getColor(x, y+1) );
|
||||
mesh.addVertex(ofVec3f(_mesh_size_multiplier*x,_mesh_size_multiplier*(y+1),- sPixels[ (currentSecondImage.getWidth()*(y+1))+x ] ));
|
||||
|
||||
mesh.addColor( currentSecondImage.getColor(x, y) );
|
||||
mesh.addVertex(ofVec3f(_mesh_size_multiplier*x,_mesh_size_multiplier*y,- sPixels[(currentSecondImage.getWidth()*(y))+x ] ));
|
||||
|
||||
mesh.addColor( currentSecondImage.getColor(x+1, y+1) );
|
||||
mesh.addVertex(ofVec3f(_mesh_size_multiplier*(x+1),_mesh_size_multiplier*(y+1),- sPixels[(currentSecondImage.getWidth()*(y+1))+x+1 ] ));
|
||||
|
||||
mesh.addColor( currentSecondImage.getColor(x+1, y+1) );
|
||||
mesh.addVertex(ofVec3f(_mesh_size_multiplier*(x+1),_mesh_size_multiplier*(y+1),- sPixels[(currentSecondImage.getWidth()*(y+1))+x+1] ));
|
||||
|
||||
mesh.addColor( currentSecondImage.getColor(x, y) );
|
||||
mesh.addVertex(ofVec3f(_mesh_size_multiplier*x,_mesh_size_multiplier*y,- sPixels[(currentSecondImage.getWidth()*(y))+x ] ));
|
||||
|
||||
mesh.addColor( currentSecondImage.getColor(x+1, y) );
|
||||
mesh.addVertex(ofVec3f(_mesh_size_multiplier*(x+1),_mesh_size_multiplier*y,- sPixels[(currentSecondImage.getWidth()*(y))+x +1 ]));
|
||||
|
||||
x++;
|
||||
if(x>=currentSecondImage.getWidth()-1){
|
||||
x=0;
|
||||
y++;
|
||||
//something is going badly wrong with my maths for me to need this HELP TODO fix this - why am I running over the end of the vector?
|
||||
if(y>=479){
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
/*else{
|
||||
for(int i=0;i<somePixels.getWidth()*(somePixels.getHeight()-1);i++){
|
||||
|
||||
|
||||
ofVec3f U;
|
||||
ofVec3f V;
|
||||
//tri 1
|
||||
U =ofVec3f(_mesh_size_multiplier*x,_mesh_size_multiplier*y,- somePixels.getColor(x, y).getBrightness() ).operator- ( ofVec3f(_mesh_size_multiplier*x,_mesh_size_multiplier*(y+1),- somePixels.getColor(x, y).getBrightness() ) );
|
||||
V =ofVec3f(_mesh_size_multiplier*(x+1),_mesh_size_multiplier*(y+1),- somePixels.getColor(x+1, y+1).getBrightness() ).operator-(ofVec3f(_mesh_size_multiplier*x,_mesh_size_multiplier*y,- somePixels.getColor(x, y).getBrightness() ));
|
||||
|
||||
ofVec3f normal;
|
||||
float mult=5.2;
|
||||
normal = ofVec3f( (U.y*V.z)-(U.z-V.y) , (U.z*V.x)-(U.x*V.z) , (U.x*V.y)-(U.y*V.x) );
|
||||
|
||||
mesh.addColor(meshColour);
|
||||
mesh.addVertex(ofVec3f(_mesh_size_multiplier*x,_mesh_size_multiplier*(y+1),- mult*(1+somePixels.getColor(x, y+1).getBrightness() ) ));
|
||||
|
||||
mesh.addColor(meshColour);
|
||||
mesh.addVertex(ofVec3f(_mesh_size_multiplier*x,_mesh_size_multiplier*y,- mult*(1+somePixels.getColor(x, y).getBrightness() ) ));
|
||||
|
||||
mesh.addColor(meshColour);
|
||||
mesh.addVertex(ofVec3f(_mesh_size_multiplier*(x+1),_mesh_size_multiplier*(y+1),- mult*(1+somePixels.getColor(x+1, y+1).getBrightness()) ));
|
||||
|
||||
mesh.addNormal(normal);
|
||||
|
||||
//tri 2
|
||||
U =ofVec3f(_mesh_size_multiplier*(x),_mesh_size_multiplier*y,- somePixels.getColor(x, y).getBrightness() ).operator-(ofVec3f(_mesh_size_multiplier*(x+1),_mesh_size_multiplier*(y+1),- somePixels.getColor(x+1, y+1).getBrightness() ) );
|
||||
V =ofVec3f(_mesh_size_multiplier*(x+1),_mesh_size_multiplier*y,- somePixels.getColor(x+1, y).getBrightness() ).operator-(ofVec3f(_mesh_size_multiplier*(x+1),_mesh_size_multiplier*(y+1),- somePixels.getColor(x+1, y+1).getBrightness() ) );
|
||||
|
||||
normal = ofVec3f( (U.y*V.z)-(U.z-V.y) , (U.z*V.x)-(U.x*V.z) , (U.x*V.y)-(U.y*V.x) );
|
||||
|
||||
mesh.addColor(meshColour);
|
||||
mesh.addVertex(ofVec3f(_mesh_size_multiplier*(x+1),_mesh_size_multiplier*(y+1),- mult*(1+somePixels.getColor(x+1, y+1).getBrightness()) ));
|
||||
// mesh.addColor( ofColor(255,10,10) );
|
||||
|
||||
mesh.addColor(meshColour);
|
||||
mesh.addVertex(ofVec3f(_mesh_size_multiplier*(x),_mesh_size_multiplier*y,- mult*(1+somePixels.getColor(x, y).getBrightness() ) ));
|
||||
|
||||
mesh.addColor(meshColour);
|
||||
mesh.addVertex(ofVec3f(_mesh_size_multiplier*(x+1),_mesh_size_multiplier*y,-mult*(1+ somePixels.getColor(x+1, y).getBrightness()) ));
|
||||
|
||||
mesh.addNormal(normal);
|
||||
|
||||
x++;
|
||||
if(x>=somePixels.getWidth()-1){
|
||||
x=0;
|
||||
y++;
|
||||
if(y>=479){
|
||||
break;
|
||||
}
|
||||
}
|
||||
}*/
|
||||
|
||||
// add colour from current second image of two - this is a hang over from when i was comparing two image
|
||||
|
||||
|
||||
}
|
||||
vector<float> IResponseAnalysis::_returnDepthsAtEachPixel(ofImage &image1, ofImage &image2, ofImage &backgroundImag){
|
||||
|
||||
ofPixels imagePixels1 = image1.getPixelsRef();
|
||||
ofPixels imagePixels2 = image2.getPixelsRef();
|
||||
ofPixels backgroundPixels = backgroundImag.getPixelsRef();
|
||||
vector<float> differences;
|
||||
|
||||
ofPixels difference;
|
||||
//this unsigned char should be unnecessary - I would have thought - can't you just address the pixel locations in ofPixels directly?
|
||||
unsigned char * thesePixels = new unsigned char[ imagePixels1.getWidth()*imagePixels1.getHeight()*3];
|
||||
for(int i=0;i<imagePixels1.size();i++){
|
||||
thesePixels[i]=0;
|
||||
}
|
||||
int x=0;
|
||||
int y=0;
|
||||
|
||||
int chooseComparison=1;
|
||||
|
||||
//the current version compares how bright this pixel is with how bright it would be following inverse square fall off from centre
|
||||
if(chooseComparison==1){
|
||||
//for each pixel...
|
||||
float _maxPossibleDistanceToCentre=ofDist(0,0,imagePixels1.getWidth()/2, imagePixels1.getHeight()/2);
|
||||
for(int i=0;i<imagePixels1.size();i+=3){
|
||||
|
||||
ofColor colourImage1 = imagePixels1.getColor(x, y);
|
||||
//ofColor colourImage2 = imagePixels2.getColor(x, y);
|
||||
|
||||
float _distanceToCentre=ofDist(imagePixels1.getWidth()/2, imagePixels1.getHeight()/2, x, y);
|
||||
float _presumedBrightness=ofMap( sqrt(_maxPossibleDistanceToCentre)-sqrt(_distanceToCentre), 0, sqrt(_maxPossibleDistanceToCentre), 0, 255);
|
||||
//float _presumedBrightness=255;
|
||||
int thisDiff=abs(colourImage1.getBrightness()-_presumedBrightness);
|
||||
//cout<<thisDiff<< " thisDiff "<<endl;
|
||||
float multiplier=2.0;
|
||||
differences.push_back(multiplier* thisDiff);
|
||||
thesePixels[i]=thisDiff;
|
||||
thesePixels[i+1]=thisDiff;
|
||||
thesePixels[i+2]=thisDiff;
|
||||
x++;
|
||||
if(x>=imagePixels1.getWidth()){
|
||||
x=0;
|
||||
y++;
|
||||
|
||||
}
|
||||
|
||||
}
|
||||
}
|
||||
|
||||
difference.setFromPixels(thesePixels,imagePixels1.getWidth(),imagePixels1.getHeight(), 3);
|
||||
return differences;
|
||||
|
||||
}
|
||||
|
||||
|
||||
|
||||
+30
-6
@@ -35,14 +35,38 @@ 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;
|
||||
|
||||
//mesh making function
|
||||
void setMeshFromPixels(vector<float> sPixels, ofImage currentFirstImage, ofImage currentSecondImage, ofMesh & mesh);
|
||||
//returns ofPixels but these pixels actually hold depth data.
|
||||
//ofPixels make3DZmap(ofImage &image1, ofImage &image2, ofImage &backgroundImage);
|
||||
vector<float> _returnDepthsAtEachPixel(ofImage &image1, ofImage &image2, ofImage &backgroundImage);
|
||||
bool _gotFirstImage;
|
||||
ofImage _background;
|
||||
};
|
||||
|
||||
+95
-77
@@ -12,12 +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 int line_width_default = 0.5f;
|
||||
const float point_size_default = 0.5f;
|
||||
#define TRESHOLD 80
|
||||
#define MAXBLOBS 15
|
||||
|
||||
void RelaxRateAnalysis::setup(int camWidth, int camHeight)
|
||||
{
|
||||
@@ -31,6 +27,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;
|
||||
|
||||
_treshold = RefractiveIndex::XML.getValue("config:relaxrate:treshold", TRESHOLD);
|
||||
cout << "TRESHOLD RelaxRateAnalysis " << _treshold << endl;
|
||||
|
||||
_maxblobs = RefractiveIndex::XML.getValue("config:relaxrate:maxblobs", MAXBLOBS);
|
||||
cout << "MAXBLOBS RelaxRateAnalysis " << _maxblobs << endl;
|
||||
|
||||
|
||||
//int acq_run_time = 20; // 20 seconds of acquiring per run
|
||||
|
||||
DELTA_T_SAVE = 2*(10*acq_run_time/2); // for 20 seconds, we want this to be around 200 files
|
||||
// or 10 times per second = every 100 ms
|
||||
|
||||
@@ -52,23 +57,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,52 +101,76 @@ 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(_treshold);
|
||||
|
||||
rfiCvContourFinder* cf = new rfiCvContourFinder();
|
||||
|
||||
cf->findContours(cvGrayDiff1, 20, (image1.width * image1.height) / 4, _maxblobs, true);
|
||||
|
||||
cvContourFinderVect.push_back(cf);
|
||||
|
||||
}
|
||||
}
|
||||
|
||||
// _saved_filenames_synthesis has processed all the files in the analysis images folder
|
||||
while(!_RUN_DONE && _state != STATE_STOP)
|
||||
Thread::sleep(3);
|
||||
*/
|
||||
|
||||
|
||||
}
|
||||
|
||||
void RelaxRateAnalysis::displayresults()
|
||||
{
|
||||
|
||||
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;
|
||||
|
||||
|
||||
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;
|
||||
cvContourFinderVectDisplay.push_back(cvContourFinderVect[i]);
|
||||
_show_image = true;
|
||||
_image_shown = false;
|
||||
|
||||
}
|
||||
}
|
||||
|
||||
clearcfindervectdisplay();
|
||||
clearcfindervect();
|
||||
|
||||
|
||||
//cvContourFinderVectDisplay.clear();
|
||||
//cvContourFinderVect.clear();
|
||||
|
||||
|
||||
}
|
||||
|
||||
@@ -289,47 +312,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);
|
||||
|
||||
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;
|
||||
{
|
||||
for(int i=0;i<cvContourFinderVectDisplay.size();i++){
|
||||
cvContourFinderVectDisplay[i]->draw(0,0, ofGetWidth(), ofGetHeight());
|
||||
}
|
||||
|
||||
RefractiveIndex::_shader.end();
|
||||
|
||||
image2.unbind();
|
||||
|
||||
RefractiveIndex::cam.end();
|
||||
}
|
||||
|
||||
// display results of the synthesis
|
||||
_RUN_DONE = true;
|
||||
break;
|
||||
|
||||
}
|
||||
@@ -348,5 +340,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,6 +31,8 @@ public:
|
||||
|
||||
protected:
|
||||
|
||||
void clearcfindervect();
|
||||
void clearcfindervectdisplay();
|
||||
|
||||
bool _RUN_DONE;
|
||||
float _flip, _level;
|
||||
@@ -42,12 +45,10 @@ protected:
|
||||
bool _show_image, _image_shown;
|
||||
|
||||
ofImage image1;
|
||||
ofImage image2;
|
||||
ofxCvColorImage cvColorImage1;
|
||||
ofxCvGrayscaleImage cvGrayDiff1;
|
||||
|
||||
int algo;
|
||||
int scale;
|
||||
int draw_style;
|
||||
float line_width;
|
||||
float point_size;
|
||||
vector<rfiCvContourFinder*> cvContourFinderVect;
|
||||
vector<rfiCvContourFinder*> cvContourFinderVectDisplay;
|
||||
|
||||
};
|
||||
|
||||
+124
-54
@@ -17,11 +17,6 @@ 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);
|
||||
@@ -47,7 +42,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 +55,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,26 +126,93 @@ 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 << "ShadowScapesAnalysis::synthesis FOR LOOP...\n";
|
||||
|
||||
// cout << "_saved_filenames_analysis[i]" << _saved_filenames_analysis[i] << endl;
|
||||
|
||||
//cout << "IResponseAnalysis::saving synthesis...\n";
|
||||
if(_state == STATE_STOP) return;
|
||||
|
||||
_RUN_DONE = 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_analysis.size();i++){
|
||||
for(float i=1;i<_saved_filenames_synthesis.size();i++){
|
||||
|
||||
if(_state == STATE_STOP) return;
|
||||
|
||||
@@ -132,20 +223,19 @@ void ShadowScapesAnalysis::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;
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
|
||||
@@ -333,47 +423,27 @@ void ShadowScapesAnalysis::draw()
|
||||
|
||||
_frame_cnt++;
|
||||
|
||||
if (_show_image)
|
||||
{
|
||||
// cout << "_show_image...\n" << endl;
|
||||
|
||||
ofEnableAlphaBlending();
|
||||
glShadeModel(GL_SMOOTH);
|
||||
glLineWidth(line_width);
|
||||
|
||||
RefractiveIndex::cam.begin();
|
||||
ofSetColor(255, 255, 255);
|
||||
|
||||
ofTranslate(tx, ty, tz);
|
||||
ofRotateX(rx); ofRotateY(ry); ofRotateZ(rz);
|
||||
glScalef(1.5, 1, 1);
|
||||
image2.setFromPixels(image3.getPixels(),image3.width,image3.height, OF_IMAGE_COLOR);
|
||||
image2.draw(0,0, ofGetWidth(), ofGetHeight());
|
||||
|
||||
if (_show_image)
|
||||
image2.setFromPixels(image1.getPixels(), image1.width, image1.height, OF_IMAGE_COLOR);
|
||||
ofDisableAlphaBlending();
|
||||
|
||||
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;
|
||||
|
||||
// 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,13 +13,6 @@ 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);
|
||||
@@ -54,21 +47,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,27 +146,82 @@ void ShapeFromShadingAnalysis::acquire()
|
||||
|
||||
void ShapeFromShadingAnalysis::synthesise()
|
||||
{
|
||||
// we don't need to synthesise
|
||||
return;
|
||||
|
||||
/*
|
||||
|
||||
//cout << "IResponseAnalysis::saving synthesis...\n";
|
||||
// cout << "ShapeFromShadingAnalysis::saving synthesis...\n";
|
||||
if(_state == STATE_STOP) return;
|
||||
|
||||
_RUN_DONE = false;
|
||||
for(float i=1;i<_saved_filenames_analysis.size()-1;i++){
|
||||
|
||||
// cout << "ShapeFromShadingAnalysis::synthesis FOR LOOP...\n";
|
||||
|
||||
// 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)+"_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_analysis.size();i++){
|
||||
for(float i=1;i<_saved_filenames_synthesis.size();i++){
|
||||
|
||||
if(_state == STATE_STOP) return;
|
||||
|
||||
@@ -155,15 +232,13 @@ void ShapeFromShadingAnalysis::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;
|
||||
@@ -477,6 +552,8 @@ void ShapeFromShadingAnalysis::draw()
|
||||
|
||||
case STATE_DISPLAY_RESULTS:
|
||||
{
|
||||
// cout << "STATE_DISPLAY_RESULTS...\n" << endl;
|
||||
|
||||
if (_frame_cnt > 2)
|
||||
{
|
||||
_image_shown = true;
|
||||
@@ -485,50 +562,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;
|
||||
|
||||
};
|
||||
|
||||
+115
-64
@@ -13,12 +13,6 @@ 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);
|
||||
@@ -54,24 +48,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,26 +128,83 @@ void StrobeAnalysis::acquire()
|
||||
|
||||
void StrobeAnalysis::synthesise()
|
||||
{
|
||||
// we don't need to synthesise
|
||||
return;
|
||||
|
||||
/*
|
||||
|
||||
//cout << "IResponseAnalysis::saving synthesis...\n";
|
||||
// cout << "StrobeAnalysis::saving synthesis...\n";
|
||||
if(_state == STATE_STOP) return;
|
||||
|
||||
_RUN_DONE = false;
|
||||
for(float i=1;i<_saved_filenames_analysis.size()-1;i++){
|
||||
|
||||
// cout << "StrobeAnalysis::synthesis FOR LOOP...\n";
|
||||
|
||||
// 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.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;
|
||||
|
||||
@@ -138,15 +215,13 @@ void StrobeAnalysis::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;
|
||||
@@ -306,6 +381,8 @@ void StrobeAnalysis::draw()
|
||||
case STATE_DISPLAY_RESULTS:
|
||||
{
|
||||
|
||||
// cout << "STATE_DISPLAY_RESULTS...\n" << endl;
|
||||
|
||||
if (_frame_cnt > 2)
|
||||
{
|
||||
_image_shown = true;
|
||||
@@ -314,47 +391,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