void Microsoft2Grabber::GetPointCloudFromColorlessData(const MatDepth &depth, boost::shared_ptr<PointCloud<PointXYZRGBA>> &cloud, bool alignToColor, bool preregistered) const
{
if(depth.empty()) {
cout << "empty depth" << endl;
return;
}
UINT16 *pDepth = (UINT16*)depth.data;
int length = cDepthHeight * cDepthWidth, length2;
HRESULT hr;
if(alignToColor) {
length2 = cColorHeight * cColorWidth;
hr = m_pCoordinateMapper->MapColorFrameToCameraSpace(length,pDepth,length2,m_pCameraSpacePoints);
if(FAILED(hr))
throw exception("Couldn't map to camera!");
} else {
hr = m_pCoordinateMapper->MapDepthFrameToCameraSpace(length,pDepth,length,m_pCameraSpacePoints);
if(FAILED(hr))
throw exception("Couldn't map to camera!");
hr = m_pCoordinateMapper->MapCameraPointsToColorSpace(length,m_pCameraSpacePoints,length,m_pColorCoordinates);
if(FAILED(hr))
throw exception("Couldn't map color!");
}
PointCloud<PointXYZRGBA>::iterator pCloud = cloud->begin();
ColorSpacePoint *pColor = m_pColorCoordinates;
CameraSpacePoint *pCamera = m_pCameraSpacePoints;
float bad_point = std::numeric_limits<float>::quiet_NaN ();
int x,y, safeWidth = cColorWidth - 1, safeHeight = cColorHeight - 1;
int width = alignToColor ? cColorWidth : cDepthWidth;
int height = alignToColor ? cColorHeight : cDepthHeight;
for(int j = 0; j < height; j++) {
for(int i = 0; i < width; i++) {
PointXYZRGBA loc;
Vec4b color;
if(!preregistered && !alignToColor) {
x = Clamp<int>(int(pColor->X),0,safeWidth);
y = Clamp<int>(int(pColor->Y),0,safeHeight);
//int index = y * cColorHeight + x;
color = Vec4b(255,255,255,255); // img->at<Vec4b>(y,x);
} else
color = Vec4b(255,255,255,255); // img->at<Vec4b>(j,i);
loc.b = color[0];
loc.g = color[1];
loc.r = color[2];
loc.a = 255;
if(pCamera->Z == 0) {
loc.x = loc.y = loc.z = bad_point;
} else {
loc.x = pCamera->X;
loc.y = pCamera->Y;
loc.z = pCamera->Z;
}
//cout << "Iter: " << i << ", " << j << endl;
*pCloud = loc;
++pCamera; ++pCloud; ++pColor;
}
}
//img->release();
}
void cv::viz::vtkImageMatSource::copyRGBAImage(const Mat &source, vtkSmartPointer<vtkImageData> output)
{
Vec4b* dptr = reinterpret_cast<Vec4b*>(output->GetScalarPointer());
size_t elem_step = output->GetIncrements()[1]/sizeof(Vec4b);
for (int y = 0; y < source.rows; ++y)
{
Vec4b* drow = dptr + elem_step * y;
const unsigned char *srow = source.ptr<unsigned char>(y);
for (int x = 0; x < source.cols; ++x, srow += source.channels())
drow[x] = Vec4b(srow[2], srow[1], srow[0], srow[3]);
}
}
void MeshRenderer :: renderToImage(cv::Mat4b& image, const Pose3D& pose, int flags)
{
m_pbuffer->makeCurrent();
glMatrixMode (GL_MODELVIEW);
glLoadIdentity ();
if (flags & LIGHTING)
{
GLfloat mat_specular[] = { 1.0, 1.0, 1.0, 1.0 };
GLfloat mat_shininess[] = { 10.0 };
GLfloat light_position[] = { 1, 1, 1.0, 0.0 };
glEnable(GL_LIGHTING);
glShadeModel (GL_SMOOTH);
glEnable(GL_COLOR_MATERIAL);
glMaterialfv(GL_FRONT, GL_SPECULAR, mat_specular);
glMaterialfv(GL_FRONT, GL_SHININESS, mat_shininess);
glLightfv(GL_LIGHT0, GL_POSITION, light_position);
glEnable(GL_LIGHT0);
}
computeProjectionMatrix(image, pose);
glClearColor(1.0f, 0.0f, 0.0f, 0.0f);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
if (flags & WIREFRAME)
glPolygonMode( GL_FRONT_AND_BACK, GL_LINE );
// draw the display list
glCallList(m_list_index);
glFlush();
computeDepthBuffer();
QImage qimage = m_pbuffer->toImage();
for (int r = 0; r < qimage.height(); ++r)
for (int c = 0; c < qimage.width(); ++c)
{
QRgb pixel = qimage.pixel(c,r);
Vec4b color (qBlue(pixel), qGreen(pixel), qRed(pixel), qAlpha(pixel));
m_color_buffer(r,c) = color;
float a = qAlpha(pixel)/255.f;
if (a > 0)
{
Vec4b old_color = image(r,c);
image(r,c) = Vec4b(old_color[0]*(1-a) + color[0]*a,
old_color[1]*(1-a) + color[1]*a,
old_color[2]*(1-a) + color[2]*a,
255);
}
}
}
void MeshRenderer :: renderToImage(cv::Mat4b& image, int flags)
{
ntk_assert(m_vertex_buffer_object.initialized,
"Renderer not initialized! Call setPose and setMesh.");
ntk::TimeCount tc_gl_current("make_current", 2);
m_pbuffer->makeCurrent();
tc_gl_current.stop();
ntk::TimeCount tc_gl_render("gl_render", 2);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
if (flags & WIREFRAME)
glPolygonMode( GL_FRONT_AND_BACK, GL_LINE );
VertexBufferObject& vbo = m_vertex_buffer_object;
glBindBufferARB(GL_ARRAY_BUFFER_ARB, vbo.vertex_id);
if (vbo.has_texcoords)
{
glEnable(GL_TEXTURE_2D);
glBindTexture(GL_TEXTURE_2D, vbo.texture_id);
}
else
{
glDisable(GL_TEXTURE_2D);
}
if (vbo.has_texcoords)
glEnableClientState(GL_TEXTURE_COORD_ARRAY);
if (vbo.has_color)
glEnableClientState(GL_COLOR_ARRAY);
else
glColor3f(1.0f,0.f,0.f);
glEnableClientState(GL_VERTEX_ARRAY);
glVertexPointer(3, GL_FLOAT, 0, 0);
if (vbo.has_color)
glColorPointer(3, GL_UNSIGNED_BYTE, 0, ((char*) NULL) + vbo.color_offset);
if (vbo.has_texcoords)
glTexCoordPointer(2, GL_FLOAT, 0, ((char*) NULL) + vbo.texture_offset);
if (vbo.has_faces)
{
glBindBufferARB(GL_ELEMENT_ARRAY_BUFFER_ARB, vbo.faces_id);
glNormal3f(0, 0, 1);
glDrawElements(GL_TRIANGLES, vbo.nb_faces*3, GL_UNSIGNED_INT, 0);
if (flags & OUTLINE)
{
// Draw again for outline.
glPolygonMode( GL_FRONT_AND_BACK, GL_LINE );
glDrawElements(GL_TRIANGLES, vbo.nb_faces*3, GL_UNSIGNED_INT, 0);
glPolygonMode( GL_FRONT_AND_BACK, GL_FILL );
}
}
else
{
glDrawArrays(GL_POINTS,
0,
vbo.nb_vertices);
}
glDisableClientState(GL_VERTEX_ARRAY);
if (vbo.has_color)
glDisableClientState(GL_COLOR_ARRAY);
if (vbo.has_texcoords)
glDisableClientState(GL_TEXTURE_COORD_ARRAY);
// bind with 0, so, switch back to normal pointer operation
glBindBufferARB(GL_ARRAY_BUFFER_ARB, 0);
if (vbo.has_faces)
{
glBindBufferARB(GL_ELEMENT_ARRAY_BUFFER_ARB, 0);
}
glFinish();
tc_gl_render.stop();
ntk::TimeCount tc_image("to_image", 2);
QImage qimage = m_pbuffer->toImage();
tc_image.stop();
ntk::TimeCount tc_depth_buffer("compute_depth_buffer", 2);
computeDepthBuffer();
tc_depth_buffer.stop();
ntk::TimeCount tc_convert("convert_to_cv", 2);
for (int r = 0; r < qimage.height(); ++r)
for (int c = 0; c < qimage.width(); ++c)
{
QRgb pixel = qimage.pixel(c,r);
Vec4b color (qBlue(pixel), qGreen(pixel), qRed(pixel), qAlpha(pixel));
m_color_buffer(r,c) = color;
float a = qAlpha(pixel)/255.f;
if (a > 0)
{
Vec4b old_color = image(r,c);
image(r,c) = Vec4b(old_color[0]*(1-a) + color[0]*a,
old_color[1]*(1-a) + color[1]*a,
old_color[2]*(1-a) + color[2]*a,
255);
}
}
tc_convert.stop();
}
void FPScreenMirror::reinitialize() {
RECT keyDim = LEDController::getInstance()->getKeyBoardDimensions(allKeys);
keyboardWidth = keyDim.right;
keyboardHeight = keyDim.bottom;
if (!captureWindowHDC || !currentProcessHWND) {
return;
}
RECT targetRect;
GetWindowRect(currentProcessHWND, &targetRect);
int clientWidth = targetRect.right - targetRect.left; // -offsetLeft - offsetRight;
int clientHeight = targetRect.bottom - targetRect.top; // -offsetTop - offsetBottom;
// targetWidth = uiWidth - marginLeft * 2;
// float aspectRatio = (float)keyboardHeight / (float)keyboardWidth;
// targetHeight = (int)floor(targetWidth * aspectRatio);
keyboardZoomFactor = (float)(clientWidth - offsetLeft - offsetRight) / (float)keyboardWidth;
uiZoom = (float)targetWidth / (float)clientWidth;
// create Alpha Screenhot Mask
int cB = 80;
if (mask) {
delete mask;
}
mask = new Mat4b(targetHeight, targetWidth, CV_8UC4);
for (int i = 0; i < cB; i++) {
int c = (int)floor((float)i / (float)cB * (float)192);
Scalar color(c, c, c, 255);
cv::rectangle(*mask, cv::Point((int)floor(i), i), cv::Point(targetWidth - (int)floor(i), targetHeight - i), color, CV_FILLED, 8, 0);
}
// keyboard graphics
int keyShadowSize = 4;
if (keyboardFx) {
delete keyboardFx;
}
keyboardFx = new Mat4b(targetHeight, targetWidth, Vec4b(0, 0, 0, 0));
vector<CorsairLedPosition>::iterator it;
it = allKeys.begin();
for (; it != allKeys.end(); ) {
cv::Rect keyRect(
(int)floor((float)(it->left*keyboardZoomFactor + offsetLeft)*uiZoom * offsetScaleX),
(int)floor((float)(it->top*keyboardZoomFactor + offsetTop)*uiZoom* offsetScaleY),
(int)floor((float)it->width*keyboardZoomFactor*uiZoom * offsetScaleX),
(int)floor((float)it->height*keyboardZoomFactor*uiZoom* offsetScaleY));
for (int i = keyShadowSize; i > 0; i--) {
int c = (int)floor((float)(keyShadowSize - i) / (float)keyShadowSize * (float)192);
Scalar color(0, 0, 0, c);
cv::rectangle(*keyboardFx, cv::Rect(keyRect.x - i, keyRect.y - (int)floor((float)i / 2), keyRect.width + i * 2, keyRect.height + i * 2), color, CV_FILLED, 8, 0);
}
++it;
}
initialized = true;
}
int CPoissonExt:: prepare(int side, cv::Mat &extends)
{
int size=0;
int sign;
cv::Mat *image;
if(side==1)
sign=1,image=&_image2;
else
sign=-1,image=&_image1;
for(int y=0;y<h+ex*2;y++)
for (int x=0;x<w+ex*2;x++)
{
int ii=y*(w+2*ex)+x;
if((extends.at<Vec4b>(y,x))[3]>0)
{
type[ii]=2;
index[ii]=size++;
}
else
{
//4ÁÚÓò
if(y>0&&(extends.at<Vec4b>(y-1,x))[3]>0)
{
type[ii]=1;
index[ii]=size++;
continue;
}
if(y<h+ex*2-1&&(extends.at<Vec4b>(y+1,x))[3]>0)
{
type[ii]=1;
index[ii]=size++;
continue;
}
if(x>0&&(extends.at<Vec4b>(y,x-1))[3]>0)
{
type[ii]=1;
index[ii]=size++;
continue;
}
if(x<w+ex*2-1&&(extends.at<Vec4b>(y,x+1))[3]>0)
{
type[ii]=1;
index[ii]=size++;
continue;
}
type[ii]=0;
}
}
#pragma omp parallel for
for(int y=0;y<h+ex*2;y++)
for (int x=0;x<w+ex*2;x++)
{
int ii=y*(w+2*ex)+x;
if(type[ii]==2)//outside
{
Vec3f q,p,v;
q[0]=x-ex;
q[1]=y-ex;
p=q;
v=BilineaGetColor_clamp<Vec3f,Vec3f>(_vector,p[0],p[1]);
float alpha=0.8;
for(int i=0;i<20;i++)
{
p=q+v*sign;
v=alpha*BilineaGetColor_clamp<Vec3f,Vec3f>(_vector,p[0],p[1])+(1-alpha)*v;
}
q=p+v*sign;
if(q[0]>=0&&q[1]>=0&&q[0]<w&&q[1]<h)
{
Vec4b rgba=BilineaGetColor_clamp<Vec4b,Vec4f>(*image,q[0],q[1]);
if(rgba[3]==0)
extends.at<Vec4b>(y,x)=rgba;
else
extends.at<Vec4b>(y,x)=Vec4b(255,0,255,0);
}
else
extends.at<Vec4b>(y,x)=Vec4b(255,0,255,0);
}
}
return size;
}
void CPoissonExt::poissonExtend_cuda(cv::Mat &dst,int size)
{
cv::Mat gx=Mat::zeros(h+2*ex,w+2*ex,CV_32FC4);
cv::Mat gy=Mat::zeros(h+2*ex,w+2*ex,CV_32FC4);
#pragma omp parallel for
for(int y=0;y<h+ex*2;y++)
for (int x=0;x<w+ex*2;x++)
{
if(type[y*(w+2*ex)+x]>1)
{
Vec4f BGRA0;
Vec4f BGRA1;
BGRA1=dst.at<Vec4b>(y,x);
if(x>0)
{
if(type[y*(w+2*ex)+x-1]>1)
{
BGRA0=dst.at<Vec4b>(y,x-1);
if(BGRA0!=Vec4f(255,0,255,0)&&BGRA1!=Vec4f(255,0,255,0))
gx.at<Vec4f>(y,x)=BGRA1-BGRA0;
}
}
if(y>0)
{
if(type[(y-1)*(w+2*ex)+x]>1)
{
BGRA0=dst.at<Vec4b>(y-1,x);
if(BGRA0!=Vec4f(255,0,255)&&BGRA1!=Vec4f(255,0,255))
gy.at<Vec4f>(y,x)=BGRA1-BGRA0;
}
}
}
}
//matrix
cusp::csr_matrix<int,float,cusp::host_memory> A(size,size,5*size-w*2-h*2);
cusp::array1d<float, cusp::host_memory> X0(A.num_rows, 0);
cusp::array1d<float, cusp::host_memory> B0(A.num_rows, 0);
cusp::array1d<float, cusp::host_memory> X1(A.num_rows, 0);
cusp::array1d<float, cusp::host_memory> B1(A.num_rows, 0);
cusp::array1d<float, cusp::host_memory> X2(A.num_rows, 0);
cusp::array1d<float, cusp::host_memory> B2(A.num_rows, 0);
// cusp::array1d<float, cusp::host_memory> X3(A.num_rows, 0);
// cusp::array1d<float, cusp::host_memory> B3(A.num_rows, 0);
int nNonZeros=0;
A.row_offsets[0]=0;
Vec4f BGRA;
for(int y=0;y<h+ex*2;y++)
for (int x=0;x<w+ex*2;x++)
{
float a[5];
a[0]=a[1]=a[2]=a[3]=a[4]=0.0f;
int ii=y*(w+2*ex)+x;
switch(type[ii])
{
case 0://inside
break;
case 1://boundary
a[2]+=1.0f;
BGRA=dst.at<Vec4b>(y,x);
B0[index[ii]]+=BGRA[0];
B1[index[ii]]+=BGRA[1];
B2[index[ii]]+=BGRA[2];
// B3[index[ii]]+=BGRA[3];
case 2://outside
if(y-1>=0&&type[ii-(w+2*ex)]>0)
{
a[2]+=1.0f;
a[0]-=1.0f;
BGRA=gy.at<Vec4f>(y,x);
B0[index[ii]]+=BGRA[0];
B1[index[ii]]+=BGRA[1];
B2[index[ii]]+=BGRA[2];
// B3[index[ii]]+=BGRA[3];
}
if(x-1>=0&&type[ii-1]>0)
{
a[2]+=1.0f;
a[1]-=1.0f;
BGRA=gx.at<Vec4f>(y,x);
B0[index[ii]]+=BGRA[0];
B1[index[ii]]+=BGRA[1];
B2[index[ii]]+=BGRA[2];
// B3[index[ii]]+=BGRA[3];
}
if(x+1<w+2*ex&&type[ii+1]>0)
{
a[2]+=1.0f;
a[3]-=1.0f;
BGRA=gx.at<Vec4f>(y,x+1);
B0[index[ii]]-=BGRA[0];
B1[index[ii]]-=BGRA[1];
B2[index[ii]]-=BGRA[2];
// B3[index[ii]]+=BGRA[3];
}
if(y+1<h+2*ex&&type[ii+(w+2*ex)]>0)
{
a[2]+=1.0f;
a[4]-=1.0f;
BGRA=gy.at<Vec4f>(y+1,x);
B0[index[ii]]-=BGRA[0];
B1[index[ii]]-=BGRA[1];
B2[index[ii]]-=BGRA[2];
// B3[index[ii]]+=BGRA[3];
}
//put into A
if(a[0]!=0)
{
A.values[nNonZeros]=a[0];
A.column_indices[nNonZeros]=index[ii-(w+2*ex)];
nNonZeros++;
}
if(a[1]!=0)
{
A.values[nNonZeros]=a[1];
A.column_indices[nNonZeros]=index[ii-1];
nNonZeros++;
}
if(a[2]!=0)
{
A.values[nNonZeros]=a[2];
A.column_indices[nNonZeros]=index[ii];
nNonZeros++;
}
if(a[3]!=0)
{
A.values[nNonZeros]=a[3];
A.column_indices[nNonZeros]=index[ii+1];
nNonZeros++;
}
if(a[4]!=0)
{
A.values[nNonZeros]=a[4];
A.column_indices[nNonZeros]=index[ii+(w+2*ex)];
nNonZeros++;
}
A.row_offsets[index[ii]+1]=nNonZeros;
break;
}
}
//SOLVER;
solve(A,B0,X0);
solve(A,B1,X1);
solve(A,B2,X2);
// solve(A,B3,X3);
//paste
#pragma omp parallel for
for(int y=0;y<h+ex*2;y++)
for (int x=0;x<w+ex*2;x++)
{
int ii=y*(w+2*ex)+x;
if(type[ii]>0)
{
int B=MIN(MAX(X0[index[ii]],0),255);
int G=MIN(MAX(X1[index[ii]],0),255);
int R=MIN(MAX(X2[index[ii]],0),255);
int A=0;
dst.at<Vec4b>(y,x)=Vec4b(B,G,R,A);
}
}
}
void CPoissonExt::poissonExtend(cv::Mat &dst,int size)
{
cv::Mat gx=Mat::zeros(h+2*ex,w+2*ex,CV_32FC4);
cv::Mat gy=Mat::zeros(h+2*ex,w+2*ex,CV_32FC4);
#pragma omp parallel for
for(int y=0;y<h+ex*2;y++)
for (int x=0;x<w+ex*2;x++)
{
if(type[y*(w+2*ex)+x]>1)
{
Vec4f BGRA0;
Vec4f BGRA1;
BGRA1=dst.at<Vec4b>(y,x);
if(x>0)
{
if(type[y*(w+2*ex)+x-1]>1)
{
BGRA0=dst.at<Vec4b>(y,x-1);
if(BGRA0!=Vec4f(255,0,255,0)&&BGRA1!=Vec4f(255,0,255,0))
gx.at<Vec4f>(y,x)=BGRA1-BGRA0;
}
}
if(y>0)
{
if(type[(y-1)*(w+2*ex)+x]>1)
{
BGRA0=dst.at<Vec4b>(y-1,x);
if(BGRA0!=Vec4f(255,0,255,0)&&BGRA1!=Vec4f(255,0,255,0))
gy.at<Vec4f>(y,x)=BGRA1-BGRA0;
}
}
}
}
//matrix
float *A=new float[5*size];
_INTEGER_t *columns=new _INTEGER_t[5*size];
_INTEGER_t *rowindex=new _INTEGER_t[size+1];
float *B0=new float[size];
float *B1=new float[size];
float *B2=new float[size];
float *B3=new float[size];
float *X0=new float[size];
float *X1=new float[size];
float *X2=new float[size];
//float *X3=new float[size];
_INTEGER_t nNonZeros=0;
memset(A,0,5*size*sizeof(float));
memset(columns,0,5*size*sizeof(int));
memset(rowindex,0,(size+1)*sizeof(int));
memset(B0,0,size*sizeof(float));
memset(B1,0,size*sizeof(float));
memset(B2,0,size*sizeof(float));
memset(B3,0,size*sizeof(float));
memset(X0,0,size*sizeof(float));
memset(X1,0,size*sizeof(float));
memset(X2,0,size*sizeof(float));
//memset(X3,0,size*sizeof(float));
Vec4f BGRA;
for(int y=0;y<h+ex*2;y++)
for (int x=0;x<w+ex*2;x++)
{
float a[5];
a[0]=a[1]=a[2]=a[3]=a[4]=0.0f;
int ii=y*(w+2*ex)+x;
switch(type[ii])
{
case 0://inside
break;
case 1://boundary
a[2]+=1.0f;
BGRA=dst.at<Vec4b>(y,x);
B0[index[ii]]+=BGRA[0];
B1[index[ii]]+=BGRA[1];
B2[index[ii]]+=BGRA[2];
//B3[index[ii]]+=BGRA[3];
case 2://outside
if(y-1>=0&&type[ii-(w+2*ex)]>0)
{
a[2]+=1.0f;
a[0]-=1.0f;
BGRA=gy.at<Vec4f>(y,x);
B0[index[ii]]+=BGRA[0];
B1[index[ii]]+=BGRA[1];
B2[index[ii]]+=BGRA[2];
//B3[index[ii]]+=BGRA[3];
}
if(x-1>=0&&type[ii-1]>0)
{
a[2]+=1.0f;
a[1]-=1.0f;
BGRA=gx.at<Vec4f>(y,x);
B0[index[ii]]+=BGRA[0];
B1[index[ii]]+=BGRA[1];
B2[index[ii]]+=BGRA[2];
//B3[index[ii]]+=BGRA[3];
}
if(x+1<w+2*ex&&type[ii+1]>0)
{
a[2]+=1.0f;
a[3]-=1.0f;
BGRA=gx.at<Vec4f>(y,x+1);
B0[index[ii]]-=BGRA[0];
B1[index[ii]]-=BGRA[1];
B2[index[ii]]-=BGRA[2];
//B3[index[ii]]-=BGRA[3];
}
if(y+1<h+2*ex&&type[ii+(w+2*ex)]>0)
{
a[2]+=1.0f;
a[4]-=1.0f;
BGRA=gy.at<Vec4f>(y+1,x);
B0[index[ii]]-=BGRA[0];
B1[index[ii]]-=BGRA[1];
B2[index[ii]]-=BGRA[2];
//B3[index[ii]]-=BGRA[3];
}
//put into A
if(a[0]!=0)
{
A[nNonZeros]=a[0];
columns[nNonZeros]=index[ii-(w+2*ex)];
nNonZeros++;
}
if(a[1]!=0)
{
A[nNonZeros]=a[1];
columns[nNonZeros]=index[ii-1];
nNonZeros++;
}
if(a[2]!=0)
{
A[nNonZeros]=a[2];
columns[nNonZeros]=index[ii];
nNonZeros++;
}
if(a[3]!=0)
{
A[nNonZeros]=a[3];
columns[nNonZeros]=index[ii+1];
nNonZeros++;
}
if(a[4]!=0)
{
A[nNonZeros]=a[4];
columns[nNonZeros]=index[ii+(w+2*ex)];
nNonZeros++;
}
rowindex[index[ii]+1]=nNonZeros;
break;
}
}
//SOLVER
_INTEGER_t error;
_MKL_DSS_HANDLE_t solver;
_INTEGER_t opt=MKL_DSS_MSG_LVL_WARNING + MKL_DSS_TERM_LVL_ERROR + MKL_DSS_SINGLE_PRECISION + MKL_DSS_ZERO_BASED_INDEXING;
_INTEGER_t sym=MKL_DSS_NON_SYMMETRIC;
_INTEGER_t typ=MKL_DSS_POSITIVE_DEFINITE;
_INTEGER_t ord=MKL_DSS_AUTO_ORDER;
_INTEGER_t sov=MKL_DSS_DEFAULTS;
_INTEGER_t nRhs = 1;
_INTEGER_t size_l=size;
error= dss_create(solver, opt);
error = dss_define_structure(solver,sym, rowindex, size_l, size_l,columns, nNonZeros);
error = dss_reorder( solver,ord, 0);
error = dss_factor_real( solver, typ, A );
error = dss_solve_real( solver, sov, B0, nRhs, X0 );
error = dss_solve_real( solver, sov, B1, nRhs, X1 );
error = dss_solve_real( solver, sov, B2, nRhs, X2 );
//error = dss_solve_real( solver, sov, B3, nRhs, X3 );
error = dss_delete( solver, opt );
//paste
#pragma omp parallel for
for(int y=0;y<h+ex*2;y++)
for (int x=0;x<w+ex*2;x++)
{
int ii=y*(w+2*ex)+x;
if(type[ii]>0)
{
int B=MIN(MAX(X0[index[ii]],0),255);
int G=MIN(MAX(X1[index[ii]],0),255);
int R=MIN(MAX(X2[index[ii]],0),255);
int A=0;
dst.at<Vec4b>(y,x)=Vec4b(B,G,R,A);
}
}
delete[] A;
delete[] B0;
delete[] B1;
delete[] B2;
delete[] B3;
delete[] X0;
delete[] X1;
delete[] X2;
//delete[] X3;
delete[] columns;
delete[] rowindex;
}
