void fxPEF_lop(bool adj, bool add, int nb, int ndata, sf_complex* bb, sf_complex* data)
/*<linear operator>*/
{
int nd1,nd2,id;
nd1=ndata/2;
nd2=ndata/2;
dat1 = sf_complexalloc(nd1);
dat2 = sf_complexalloc(nd2);
for (id=0;id<nd1;id++) {
dat1[id]=data[id];
dat2[id]=data[id+nd1];
}
sf_cadjnull(adj, add, nb, ndata, bb, data);
cicaf1_init(nx, xx_up,lag);
cicaf1_dw_init(nx, xx_dw,lag);
carray( cicaf1_lop, cicaf1_dw_lop, adj, add, nb, nd1, nd2, bb, dat1, dat2);
//sf_array_simple(adj, add, nb, nd1, nd2, bb, dat1, dat2);
if (!adj){
for (id=0;id<nd1;id++) {
data[id]=dat1[id];
data[id+nd1]=dat2[id];
}
}
}
static void cexp(JF, js_Ast *exp)
{
int then, end;
int n;
switch (exp->type) {
case EXP_STRING: emitstring(J, F, OP_STRING, exp->string); break;
case EXP_NUMBER: emitnumber(J, F, exp->number); break;
case EXP_UNDEF: emit(J, F, OP_UNDEF); break;
case EXP_NULL: emit(J, F, OP_NULL); break;
case EXP_TRUE: emit(J, F, OP_TRUE); break;
case EXP_FALSE: emit(J, F, OP_FALSE); break;
case EXP_THIS: emit(J, F, OP_THIS); break;
case EXP_REGEXP:
emit(J, F, OP_NEWREGEXP);
emitraw(J, F, addstring(J, F, exp->string));
emitraw(J, F, exp->number);
break;
case EXP_OBJECT:
emit(J, F, OP_NEWOBJECT);
cobject(J, F, exp->a);
break;
case EXP_ARRAY:
emit(J, F, OP_NEWARRAY);
carray(J, F, exp->a);
break;
case EXP_FUN:
emitfunction(J, F, newfun(J, exp->a, exp->b, exp->c, 0));
break;
case EXP_IDENTIFIER:
emitlocal(J, F, OP_GETLOCAL, OP_GETVAR, exp);
break;
case EXP_INDEX:
cexp(J, F, exp->a);
cexp(J, F, exp->b);
emit(J, F, OP_GETPROP);
break;
case EXP_MEMBER:
cexp(J, F, exp->a);
emitstring(J, F, OP_GETPROP_S, exp->b->string);
break;
case EXP_CALL:
ccall(J, F, exp->a, exp->b);
break;
case EXP_NEW:
cexp(J, F, exp->a);
n = cargs(J, F, exp->b);
emit(J, F, OP_NEW);
emitraw(J, F, n);
break;
case EXP_DELETE:
cdelete(J, F, exp->a);
break;
case EXP_PREINC:
cassignop1(J, F, exp->a);
emit(J, F, OP_INC);
cassignop2(J, F, exp->a, 0);
break;
case EXP_PREDEC:
cassignop1(J, F, exp->a);
emit(J, F, OP_DEC);
cassignop2(J, F, exp->a, 0);
break;
case EXP_POSTINC:
cassignop1(J, F, exp->a);
emit(J, F, OP_POSTINC);
cassignop2(J, F, exp->a, 1);
emit(J, F, OP_POP);
break;
case EXP_POSTDEC:
cassignop1(J, F, exp->a);
emit(J, F, OP_POSTDEC);
cassignop2(J, F, exp->a, 1);
emit(J, F, OP_POP);
break;
case EXP_VOID:
cexp(J, F, exp->a);
emit(J, F, OP_POP);
emit(J, F, OP_UNDEF);
break;
case EXP_TYPEOF: ctypeof(J, F, exp->a); break;
case EXP_POS: cunary(J, F, exp, OP_POS); break;
case EXP_NEG: cunary(J, F, exp, OP_NEG); break;
case EXP_BITNOT: cunary(J, F, exp, OP_BITNOT); break;
case EXP_LOGNOT: cunary(J, F, exp, OP_LOGNOT); break;
case EXP_BITOR: cbinary(J, F, exp, OP_BITOR); break;
case EXP_BITXOR: cbinary(J, F, exp, OP_BITXOR); break;
case EXP_BITAND: cbinary(J, F, exp, OP_BITAND); break;
case EXP_EQ: cbinary(J, F, exp, OP_EQ); break;
case EXP_NE: cbinary(J, F, exp, OP_NE); break;
case EXP_STRICTEQ: cbinary(J, F, exp, OP_STRICTEQ); break;
case EXP_STRICTNE: cbinary(J, F, exp, OP_STRICTNE); break;
case EXP_LT: cbinary(J, F, exp, OP_LT); break;
case EXP_GT: cbinary(J, F, exp, OP_GT); break;
case EXP_LE: cbinary(J, F, exp, OP_LE); break;
case EXP_GE: cbinary(J, F, exp, OP_GE); break;
case EXP_INSTANCEOF: cbinary(J, F, exp, OP_INSTANCEOF); break;
case EXP_IN: cbinary(J, F, exp, OP_IN); break;
case EXP_SHL: cbinary(J, F, exp, OP_SHL); break;
case EXP_SHR: cbinary(J, F, exp, OP_SHR); break;
case EXP_USHR: cbinary(J, F, exp, OP_USHR); break;
case EXP_ADD: cbinary(J, F, exp, OP_ADD); break;
case EXP_SUB: cbinary(J, F, exp, OP_SUB); break;
case EXP_MUL: cbinary(J, F, exp, OP_MUL); break;
case EXP_DIV: cbinary(J, F, exp, OP_DIV); break;
case EXP_MOD: cbinary(J, F, exp, OP_MOD); break;
case EXP_ASS: cassign(J, F, exp); break;
case EXP_ASS_MUL: cassignop(J, F, exp, OP_MUL); break;
case EXP_ASS_DIV: cassignop(J, F, exp, OP_DIV); break;
case EXP_ASS_MOD: cassignop(J, F, exp, OP_MOD); break;
case EXP_ASS_ADD: cassignop(J, F, exp, OP_ADD); break;
case EXP_ASS_SUB: cassignop(J, F, exp, OP_SUB); break;
case EXP_ASS_SHL: cassignop(J, F, exp, OP_SHL); break;
case EXP_ASS_SHR: cassignop(J, F, exp, OP_SHR); break;
case EXP_ASS_USHR: cassignop(J, F, exp, OP_USHR); break;
case EXP_ASS_BITAND: cassignop(J, F, exp, OP_BITAND); break;
case EXP_ASS_BITXOR: cassignop(J, F, exp, OP_BITXOR); break;
case EXP_ASS_BITOR: cassignop(J, F, exp, OP_BITOR); break;
case EXP_COMMA:
cexp(J, F, exp->a);
emit(J, F, OP_POP);
cexp(J, F, exp->b);
break;
case EXP_LOGOR:
cexp(J, F, exp->a);
emit(J, F, OP_DUP);
end = emitjump(J, F, OP_JTRUE);
emit(J, F, OP_POP);
cexp(J, F, exp->b);
label(J, F, end);
break;
case EXP_LOGAND:
cexp(J, F, exp->a);
emit(J, F, OP_DUP);
end = emitjump(J, F, OP_JFALSE);
emit(J, F, OP_POP);
cexp(J, F, exp->b);
label(J, F, end);
break;
case EXP_COND:
cexp(J, F, exp->a);
then = emitjump(J, F, OP_JTRUE);
cexp(J, F, exp->c);
end = emitjump(J, F, OP_JUMP);
label(J, F, then);
cexp(J, F, exp->b);
label(J, F, end);
break;
default:
jsC_error(J, exp, "unknown expression: (%s)", jsP_aststring(exp->type));
}
}
bool bakeTextureMap(const Surface &src, const Surface &target) {
OCL ocl;
if (!initOpenCL(ocl, 2)) {
BAKE_LOG("Failed to initialize OpenCL.");
return false;
}
SurfaceVolume sv;
if (!buildSurfaceVolume(src, Eigen::Vector3i::Constant(64), sv)) {
BAKE_LOG("Failed to create surface volume.");
return false;
}
// Target
cl_int err;
cl::Buffer bTargetVertexPositions(ocl.ctx,
CL_MEM_READ_ONLY | CL_MEM_COPY_HOST_PTR,
target.vertexPositions.array().size() * sizeof(float),
const_cast<float*>(target.vertexPositions.data()),
&err);
ASSERT_OPENCL(err, "Failed to create vertex buffer for target.");
cl::Buffer bTargetVertexUVs(ocl.ctx,
CL_MEM_READ_ONLY | CL_MEM_COPY_HOST_PTR,
target.vertexUVs.array().size() * sizeof(float),
const_cast<float*>(target.vertexUVs.data()), &err);
ASSERT_OPENCL(err, "Failed to create UV buffer for target.");
cl::Buffer bTargetVertexNormals(ocl.ctx,
CL_MEM_READ_ONLY | CL_MEM_COPY_HOST_PTR,
target.vertexNormals.array().size() * sizeof(float),
const_cast<float*>(target.vertexNormals.data()), &err);
ASSERT_OPENCL(err, "Failed to create normals buffer for target.");
// Source
cl::Buffer bSrcVertexPositions(ocl.ctx,
CL_MEM_READ_ONLY | CL_MEM_COPY_HOST_PTR,
src.vertexPositions.array().size() * sizeof(float),
const_cast<float*>(src.vertexPositions.data()),
&err);
ASSERT_OPENCL(err, "Failed to create vertex buffer for source.");
cl::Buffer bSrcVertexNormals(ocl.ctx,
CL_MEM_READ_ONLY | CL_MEM_COPY_HOST_PTR,
src.vertexNormals.array().size() * sizeof(float),
const_cast<float*>(src.vertexNormals.data()), &err);
ASSERT_OPENCL(err, "Failed to create normals buffer for source.");
cl::Buffer bSrcVertexColors(ocl.ctx,
CL_MEM_READ_ONLY | CL_MEM_COPY_HOST_PTR,
src.vertexColors.array().size() * sizeof(float),
const_cast<float*>(src.vertexColors.data()), &err);
ASSERT_OPENCL(err, "Failed to create color buffer for source.");
// Volume
cl::Buffer bSrcVoxels(ocl.ctx,
CL_MEM_READ_ONLY | CL_MEM_COPY_HOST_PTR,
(int)sv.cells.size() * sizeof(int),
const_cast<int*>(sv.cells.data()),
&err);
ASSERT_OPENCL(err, "Failed to create voxel buffer for source.");
cl::Buffer bSrcTrianglesInVoxels(ocl.ctx,
CL_MEM_READ_ONLY | CL_MEM_COPY_HOST_PTR,
(int)sv.triangleIndices.size() * sizeof(int),
const_cast<int*>(sv.triangleIndices.data()),
&err);
ASSERT_OPENCL(err, "Failed to triangle index buffer for source.");
float minmax[8] = {
sv.bounds.min().x(), sv.bounds.min().y(), sv.bounds.min().z(), 0.f,
sv.bounds.max().x(), sv.bounds.max().y(), sv.bounds.max().z(), 0.f,
};
cl_float4 voxelSizes = {{sv.voxelSizes.x(), sv.voxelSizes.y(), sv.voxelSizes.z(), 0}};
cl_float4 invVoxelSizes = {{1.f / sv.voxelSizes.x(), 1.f / sv.voxelSizes.y(), 1.f / sv.voxelSizes.z(), 0}};
cl_int4 voxelsPerDim = {{sv.voxelsPerDimension.x(), sv.voxelsPerDimension.y(), sv.voxelsPerDimension.z(), 0}};
// Texture
const int imagesize = 512;
Image<unsigned char> texture(imagesize, imagesize, 3);
texture.toOpenCV().setTo(0);
cl::Image2D bTexture(ocl.ctx,
CL_MEM_WRITE_ONLY | CL_MEM_COPY_HOST_PTR,
cl::ImageFormat(CL_RGB, CL_UNORM_INT8),
imagesize, imagesize, 0, texture.row(0), &err);
ASSERT_OPENCL(err, "Failed to create texture image.");
int argc = 0;
ocl.kBakeTexture.setArg(0, bTargetVertexPositions);
ocl.kBakeTexture.setArg(1, bTargetVertexNormals);
ocl.kBakeTexture.setArg(2, bTargetVertexUVs);
ocl.kBakeTexture.setArg(3, bSrcVertexPositions);
ocl.kBakeTexture.setArg(4, bSrcVertexNormals);
ocl.kBakeTexture.setArg(5, bSrcVertexColors);
ocl.kBakeTexture.setArg(6, bSrcVoxels);
ocl.kBakeTexture.setArg(7, bSrcTrianglesInVoxels);
ocl.kBakeTexture.setArg(8, carray(minmax, 8));
ocl.kBakeTexture.setArg(9, sizeof(cl_float4), voxelSizes.s);
ocl.kBakeTexture.setArg(10, sizeof(cl_float4), invVoxelSizes.s);
ocl.kBakeTexture.setArg(11, sizeof(cl_int4), voxelsPerDim.s);
ocl.kBakeTexture.setArg(12, bTexture);
ocl.kBakeTexture.setArg(13, imagesize);
ocl.kBakeTexture.setArg(14, 0.5f);
ocl.kBakeTexture.setArg(15, (int)target.vertexPositions.cols()/3);
int nTrianglesDivisableBy2 = target.vertexPositions.cols()/3 + (target.vertexPositions.cols()/3) % 2;
err = ocl.q.enqueueNDRangeKernel(ocl.kBakeTexture, cl::NullRange, cl::NDRange(nTrianglesDivisableBy2), cl::NullRange);
ASSERT_OPENCL(err, "Failed to run bake kernel.");
cl::size_t<3> origin;
origin.push_back(0);
origin.push_back(0);
origin.push_back(0);
cl::size_t<3> region;
region.push_back(imagesize);
region.push_back(imagesize);
region.push_back(1);
err = ocl.q.enqueueReadImage(bTexture, false, origin, region, 0, 0, texture.row(0));
ASSERT_OPENCL(err, "Failed to read image.");
ocl.q.finish();
cv::Mat m = texture.toOpenCV();
cv::flip(m, m, 0);
cv::imwrite("input.png", m);
cv::imshow("test", m);
cv::waitKey();
return false;
}
