void StokesRm<EvalT, Traits>::
evaluateFields(typename Traits::EvalData workset)
{
for (std::size_t cell=0; cell < workset.numCells; ++cell) {
for (std::size_t qp=0; qp < numQPs; ++qp) {
for (std::size_t i=0; i < numDims; ++i) {
Rm(cell,qp,i) = 0;
Rm(cell,qp,i) += pGrad(cell,qp,i)+force(cell,qp,i);
}
}
}
}
void StokesContinuityResid<EvalT, Traits>::
evaluateFields(typename Traits::EvalData workset)
{
typedef Intrepid::FunctionSpaceTools FST;
for (std::size_t cell=0; cell < workset.numCells; ++cell) {
for (std::size_t qp=0; qp < numQPs; ++qp) {
divergence(cell,qp) = 0.0;
for (std::size_t i=0; i < numDims; ++i) {
divergence(cell,qp) += VGrad(cell,qp,i,i);
}
}
}
FST::integrate<ScalarT>(CResidual, divergence, wBF, Intrepid::COMP_CPP,
false); // "false" overwrites
contractDataFieldScalar<ScalarT>(CResidual, divergence, wBF,false); // "false" overwrites
if (havePSPG) {
for (std::size_t cell=0; cell < workset.numCells; ++cell) {
for (std::size_t node=0; node < numNodes; ++node) {
for (std::size_t qp=0; qp < numQPs; ++qp) {
for (std::size_t j=0; j < numDims; ++j) {
CResidual(cell,node) +=
TauM(cell,qp)*Rm(cell,qp,j)*wGradBF(cell,node,qp,j);
}
}
}
}
}
}
void NSRm<EvalT, Traits>::
evaluateFields(typename Traits::EvalData workset)
{
for (std::size_t cell=0; cell < workset.numCells; ++cell) {
for (std::size_t qp=0; qp < numQPs; ++qp) {
for (std::size_t i=0; i < numDims; ++i) {
if (workset.transientTerms && enableTransient)
Rm(cell,qp,i) = rho(cell,qp)*V_Dot(cell,qp,i);
else
Rm(cell,qp,i) = 0;
if (!porousMedia) // Navier-Stokes
Rm(cell,qp,i) += pGrad(cell,qp,i)+force(cell,qp,i);
else // Porous Media
Rm(cell,qp,i) += phi(cell,qp)*pGrad(cell,qp,i)+phi(cell,qp)*force(cell,qp,i);
if (porousMedia) { //permeability and Forchheimer terms
Rm(cell,qp,i) += -permTerm(cell,qp,i)+ForchTerm(cell,qp,i);
}
for (std::size_t j=0; j < numDims; ++j) {
if (!porousMedia) // Navier-Stokes
Rm(cell,qp,i) += rho(cell,qp)*V(cell,qp,j)*VGrad(cell,qp,i,j);
else // Porous Media
Rm(cell,qp,i) += rho(cell,qp)*V(cell,qp,j)*VGrad(cell,qp,i,j)/phi(cell,qp);
}
}
}
}
}
BufferOffset Assembler::DataProcShiftedRegister(const Register& rd, const Register& rn,
const Operand& operand, FlagsUpdate S, Instr op)
{
VIXL_ASSERT(operand.IsShiftedRegister());
VIXL_ASSERT(rn.Is64Bits() || (rn.Is32Bits() && is_uint5(operand.shift_amount())));
return Emit(SF(rd) | op | Flags(S) |
ShiftDP(operand.shift()) | ImmDPShift(operand.shift_amount()) |
Rm(operand.reg()) | Rn(rn) | Rd(rd));
}
void NSMomentumResid<EvalT, Traits>::
evaluateFields(typename Traits::EvalData workset)
{
for (std::size_t cell=0; cell < workset.numCells; ++cell) {
for (std::size_t node=0; node < numNodes; ++node) {
for (std::size_t i=0; i<numDims; i++) {
MResidual(cell,node,i) = 0.0;
for (std::size_t qp=0; qp < numQPs; ++qp) {
MResidual(cell,node,i) +=
(Rm(cell, qp, i)-pGrad(cell,qp,i))*wBF(cell,node,qp) -
P(cell,qp)*wGradBF(cell,node,qp,i);
for (std::size_t j=0; j < numDims; ++j) {
MResidual(cell,node,i) +=
mu(cell,qp)*(VGrad(cell,qp,i,j)+VGrad(cell,qp,j,i))*wGradBF(cell,node,qp,j);
// mu(cell,qp)*VGrad(cell,qp,i,j)*wGradBF(cell,node,qp,j);
}
}
}
}
}
if (haveSUPG) {
for (std::size_t cell=0; cell < workset.numCells; ++cell) {
for (std::size_t node=0; node < numNodes; ++node) {
for (std::size_t i=0; i<numDims; i++) {
for (std::size_t qp=0; qp < numQPs; ++qp) {
for (std::size_t j=0; j < numDims; ++j) {
MResidual(cell,node,i) +=
rho(cell,qp)*TauM(cell,qp)*Rm(cell,qp,j)*V(cell,qp,j)*wGradBF(cell,node,qp,j);
}
}
}
}
}
}
}
void DownloadFileWithCompression(struct ORACLEALLINONE *oraAllInOne, char* pDirectory,
int compressionLevel, char* pRemoteFile, char* pLocalFile,
int isKeepPartial, int isResume)
{
FILE *fp;
sword ociResult;
ub4 vCompressionLevel;
ub8 vSkipBytes;
char blobBuffer[ORA_BLOB_BUFFER_SIZE];
oraub8 vSize;
int zRet;
z_stream zStrm;
unsigned char zOut[ORA_BLOB_BUFFER_SIZE];
#ifndef _WIN32
int showProgress;
char progressLine[MAX_FMT_SIZE];
#endif
int isStdUsed;
off_t cnt;
off_t sourceSize;
struct stat fileStat;
struct BINDVARIABLE oraBindsDownload[] =
{
{ 0, SQLT_STR, ":directory", pDirectory, ORA_IDENTIFIER_SIZE + 1 },
{ 0, SQLT_INT, ":compression_level", &vCompressionLevel, sizeof(vCompressionLevel) },
{ 0, SQLT_STR, ":filename", pRemoteFile, MAX_FMT_SIZE },
{ 0, SQLT_BLOB, ":blob", &oraAllInOne->blob, sizeof(oraAllInOne->blob) },
{ 0, SQLT_INT, ":skipbytes", &vSkipBytes, sizeof(vSkipBytes) },
{ 0 }
};
struct ORACLESTATEMENT oraStmtDownload = {
#include "downloadcompr.text"
,
0, oraBindsDownload, NO_ORACLE_DEFINES };
vCompressionLevel = compressionLevel;
isStdUsed = !strcmp(pLocalFile, "-");
if (isStdUsed)
{
isResume = 0;
isKeepPartial = 1;
}
SetSessionAction(oraAllInOne, "GZIP_AND_DOWNLOAD: GZIP");
if (OCIDescriptorAlloc(oraAllInOne->envhp, (void**)&oraAllInOne->blob, OCI_DTYPE_LOB, 0, 0))
{
ExitWithError(oraAllInOne, RET_OCIINIT, ERROR_NONE, "Failed to allocate BLOB\n");
}
cnt = 0;
vSkipBytes = 0;
if (isResume)
{
if (!stat(pLocalFile, &fileStat))
vSkipBytes = cnt = fileStat.st_size;
if (!cnt)
isResume = 0;
}
#ifndef _WIN32
showProgress = 1;
if (!isatty(STDOUT_FILENO) || isStdUsed)
showProgress = 0;
if (showProgress)
start_longops_meter(oraAllInOne, 0, 1);
#endif
PrepareStmtAndBind(oraAllInOne, &oraStmtDownload);
ociResult = ExecuteStmt(oraAllInOne);
#ifndef _WIN32
if (showProgress)
stop_longops_meter();
#endif
if (ociResult)
ExitWithError(oraAllInOne, RET_ORA, ERROR_OCI, "Failed to compress file in oracle directory\n");
#ifndef _WIN32
if (showProgress)
{
if (OCILobGetLength2(oraAllInOne->svchp[0], oraAllInOne->errhp, oraAllInOne->blob, (oraub8*)&sourceSize))
ExitWithError(oraAllInOne, RET_ORA, ERROR_OCI, "Error getting BLOB length\n");
strcpy(progressLine, "TRANSFER & GUNZIP: ");
strncat(progressLine, basename(pLocalFile), MAX_FMT_SIZE - 1 - strlen(progressLine));
start_progress_meter(progressLine, sourceSize, &cnt);
}
#endif
SetSessionAction(oraAllInOne, "GZIP_AND_DOWNLOAD: DOWNLOAD");
if (!isStdUsed && (fp = fopen(pLocalFile, isResume ? "ab" : "wb")) == NULL)
{
ExitWithError(oraAllInOne, RET_FS, ERROR_OS, "Error opening a local file for writing\n");
}
if (isStdUsed)
fp = stdout;
zStrm.zalloc = Z_NULL;
zStrm.zfree = Z_NULL;
zStrm.opaque = Z_NULL;
zStrm.avail_in = 0;
zStrm.next_in = Z_NULL;
zRet = inflateInit2(&zStrm, 16+MAX_WBITS);
if (zRet != Z_OK)
{
if (!isStdUsed)
fclose(fp);
ExitWithError(oraAllInOne, RET_ZLIB, ERROR_NONE, "ZLIB initialization failed\n");
}
vSize = 0;
ociResult = OCILobRead2(oraAllInOne->svchp[0], oraAllInOne->errhp, oraAllInOne->blob, &vSize, 0, 1, blobBuffer, ORA_BLOB_BUFFER_SIZE, OCI_FIRST_PIECE, 0, 0, 0, 0);
while (ociResult == OCI_NEED_DATA || ociResult == OCI_SUCCESS)
{
cnt += vSize;
zStrm.avail_in = vSize;
zStrm.next_in = blobBuffer;
do
{
zStrm.avail_out = ORA_BLOB_BUFFER_SIZE;
zStrm.next_out = zOut;
zRet = inflate(&zStrm, Z_NO_FLUSH);
switch (zRet)
{
case Z_STREAM_ERROR:
case Z_NEED_DICT:
case Z_DATA_ERROR:
case Z_MEM_ERROR:
(void)inflateEnd(&zStrm);
if (!isStdUsed)
fclose(fp);
ExitWithError(oraAllInOne, RET_ZLIB, ERROR_NONE, "ZLIB inflate failed: %d, size %d\n", zRet, vSize);
}
fwrite(zOut, sizeof(unsigned char), ORA_BLOB_BUFFER_SIZE - zStrm.avail_out, fp);
if (ferror(fp))
{
(void)inflateEnd(&zStrm);
if (!isStdUsed)
fclose(fp);
ExitWithError(oraAllInOne, RET_DONOTEXIT, ERROR_OS, "Error writing to a local file\n");
if (!isKeepPartial)
{
if (unlink(pLocalFile))
ExitWithError(oraAllInOne, RET_FS, ERROR_OS, "Could not remove partial file %s\n", pLocalFile);
}
ExitWithError(oraAllInOne, RET_FS, ERROR_NONE, 0);
}
}
while (zStrm.avail_out == 0);
if (ociResult == OCI_SUCCESS)
break;
ociResult = OCILobRead2(oraAllInOne->svchp[0], oraAllInOne->errhp, oraAllInOne->blob, &vSize, 0, 1, blobBuffer, ORA_BLOB_BUFFER_SIZE, OCI_NEXT_PIECE, 0, 0, 0, 0);
}
#ifndef _WIN32
if (showProgress)
stop_progress_meter();
#endif
inflateEnd(&zStrm);
if (!isStdUsed)
fclose(fp);
if (ociResult != OCI_SUCCESS)
{
ExitWithError(oraAllInOne, RET_ORA, ERROR_OCI, "Error reading BLOB\n");
}
ReleaseStmt(oraAllInOne);
SetSessionAction(oraAllInOne, 0);
OCILobFreeTemporary(oraAllInOne->svchp[0], oraAllInOne->errhp, oraAllInOne->blob);
if (OCIDescriptorFree(oraAllInOne->blob, OCI_DTYPE_LOB))
{
ExitWithError(oraAllInOne, RET_OCIINIT, ERROR_NONE, "Failed to free BLOB\n");
}
oraAllInOne->blob = 0;
}
void UploadFileWithCompression(struct ORACLEALLINONE *oraAllInOne, char* pDirectory,
int compressionLevel, char* pRemoteFile, char* pLocalFile,
int isKeepPartial, int isResume)
{
FILE *fp;
sword ociResult;
char blobBuffer[ORA_BLOB_BUFFER_SIZE];
oraub8 vSize;
ub8 vSkippedBytes;
char vOpenMode[3];
ub1 piece;
int zRet, zFlush;
z_stream zStrm;
unsigned char zIn[ORA_BLOB_BUFFER_SIZE];
#ifndef _WIN32
int showProgress;
char progressLine[MAX_FMT_SIZE];
#endif
int isStdUsed;
off_t cnt;
off_t sourceSize;
struct stat fileStat;
int isError;
struct ORACLEFILEATTR oracleFileAttr;
struct BINDVARIABLE oraBindsUpload[] =
{
{ 0, SQLT_STR, ":directory", pDirectory, ORA_IDENTIFIER_SIZE + 1 },
{ 0, SQLT_STR, ":filename", pRemoteFile, MAX_FMT_SIZE },
{ 0, SQLT_STR, ":openmode", vOpenMode, sizeof(vOpenMode) },
{ 0, SQLT_INT, ":file_size", &sourceSize, sizeof(sourceSize) },
{ 0, SQLT_INT, ":skipped", &vSkippedBytes, sizeof(vSkippedBytes) },
{ 0, SQLT_BLOB, ":blob", &oraAllInOne->blob, sizeof(oraAllInOne->blob) },
{ 0 }
};
struct ORACLESTATEMENT oraStmtUpload = {
#include "uploadcompr.text"
,
0, oraBindsUpload, NO_ORACLE_DEFINES };
isStdUsed = !strcmp(pLocalFile, "-");
if (isStdUsed)
isResume = 0;
SetSessionAction(oraAllInOne, "UPLOAD_AND_GUNZIP: UPLOAD");
if (OCIDescriptorAlloc(oraAllInOne->envhp, (void**)&oraAllInOne->blob, OCI_DTYPE_LOB, 0, 0))
{
ExitWithError(oraAllInOne, RET_OCIINIT, ERROR_NONE, "Failed to allocate BLOB\n");
}
if (OCILobCreateTemporary(oraAllInOne->svchp[0], oraAllInOne->errhp, oraAllInOne->blob, OCI_DEFAULT, 0, OCI_TEMP_BLOB, TRUE/*cache*/, OCI_DURATION_SESSION))
{
ExitWithError(oraAllInOne, RET_ORA, ERROR_OCI, "Failed to create temporary BLOB\n");
}
piece = OCI_FIRST_PIECE;
#ifndef _WIN32
showProgress = 1;
if (!isatty(STDOUT_FILENO) || isStdUsed)
showProgress = 0;
#endif
cnt = vSkippedBytes = 0;
if (isResume)
{
GetOracleFileAttr(oraAllInOne, pDirectory, pRemoteFile, &oracleFileAttr);
if (oracleFileAttr.bExists)
cnt = vSkippedBytes = oracleFileAttr.length;
if (!cnt)
isResume = 0;
}
#ifndef _WIN32
if (showProgress)
{
stat(pLocalFile, &fileStat);
sourceSize = fileStat.st_size;
strcpy(progressLine, "GZIP & TRANSFER: ");
strncat(progressLine, basename(pLocalFile), MAX_FMT_SIZE - 1 - strlen(progressLine));
start_progress_meter(progressLine, sourceSize, &cnt);
}
#endif
if (!isStdUsed && (fp = fopen(pLocalFile, "rb")) == NULL)
{
ExitWithError(oraAllInOne, RET_FS, ERROR_OS, "Error opening a local file for reading\n");
}
if (isStdUsed)
fp = stdin;
if (cnt > 0)
{
if (fseek(fp, cnt, SEEK_SET))
{
fclose(fp);
ExitWithError(oraAllInOne, RET_FS, ERROR_OS, "Error setting reading position in a local file\n");
}
}
zStrm.zalloc = Z_NULL;
zStrm.zfree = Z_NULL;
zStrm.opaque = Z_NULL;
zRet = deflateInit2(&zStrm, compressionLevel ? compressionLevel : Z_DEFAULT_COMPRESSION, Z_DEFLATED, 16+MAX_WBITS, 8, Z_DEFAULT_STRATEGY);
if (zRet != Z_OK)
{
if (!isStdUsed)
fclose(fp);
ExitWithError(oraAllInOne, RET_ZLIB, ERROR_NONE, "ZLIB initialization failed\n");
}
while (!feof(fp))
{
zStrm.avail_in = fread(zIn, sizeof(unsigned char), sizeof(zIn), fp);
cnt += zStrm.avail_in;
if (ferror(fp))
{
(void)deflateEnd(&zStrm);
if (!isStdUsed)
fclose(fp);
ExitWithError(oraAllInOne, RET_FS, ERROR_OS, "Error reading from a local file\n");
}
zFlush = feof(fp) ? Z_FINISH : Z_NO_FLUSH;
zStrm.next_in = zIn;
do
{
zStrm.avail_out = ORA_BLOB_BUFFER_SIZE;
zStrm.next_out = blobBuffer;
zRet = deflate(&zStrm, zFlush);
if (zRet != Z_OK && zRet != Z_STREAM_END && zRet != Z_BUF_ERROR)
{
(void)deflateEnd(&zStrm);
if (!isStdUsed)
fclose(fp);
ExitWithError(oraAllInOne, RET_ZLIB, ERROR_NONE, "ZLIB deflate failed: %d, size %d\n", zRet, zStrm.avail_in);
}
if (zRet == Z_STREAM_END)
piece = (piece == OCI_FIRST_PIECE) ? OCI_ONE_PIECE : OCI_LAST_PIECE;
vSize = (piece == OCI_ONE_PIECE) ? ORA_BLOB_BUFFER_SIZE - zStrm.avail_out : 0;
if (zStrm.avail_out == ORA_BLOB_BUFFER_SIZE)
continue;
ociResult = OCILobWrite2(oraAllInOne->svchp[0], oraAllInOne->errhp, oraAllInOne->blob, &vSize, 0, 1, blobBuffer, ORA_BLOB_BUFFER_SIZE - zStrm.avail_out, piece, 0, 0, 0, 0);
if (ociResult != OCI_NEED_DATA && ociResult)
{
(void)deflateEnd(&zStrm);
if (!isStdUsed)
fclose(fp);
ExitWithError(oraAllInOne, RET_ORA, ERROR_OCI, "Error writing to BLOB\n");
}
if (piece == OCI_FIRST_PIECE)
piece = OCI_NEXT_PIECE;
}
while (zStrm.avail_out == 0);
}
#ifndef _WIN32
if (showProgress)
stop_progress_meter();
#endif
deflateEnd(&zStrm);
if (!isStdUsed)
fclose(fp);
isError = 0;
strcpy(vOpenMode, isResume ? "ab" : "wb");
SetSessionAction(oraAllInOne, "UPLOAD_AND_GUNZIP: GUNZIP");
#ifndef _WIN32
if (showProgress)
start_longops_meter(oraAllInOne, 0, 1);
#endif
PrepareStmtAndBind(oraAllInOne, &oraStmtUpload);
ociResult = ExecuteStmt(oraAllInOne);
#ifndef _WIN32
if (showProgress)
stop_longops_meter();
#endif
if (ociResult)
{
ExitWithError(oraAllInOne, RET_DONOTEXIT, ERROR_OCI, "Failed to decompress file in oracle directory\n");
isError = 1;
}
else
ReleaseStmt(oraAllInOne);
SetSessionAction(oraAllInOne, 0);
OCILobFreeTemporary(oraAllInOne->svchp[0], oraAllInOne->errhp, oraAllInOne->blob);
if (OCIDescriptorFree(oraAllInOne->blob, OCI_DTYPE_LOB))
{
if (!isError)
ExitWithError(oraAllInOne, RET_DONOTEXIT, ERROR_NONE, "Failed to free BLOB\n");
isError = 1;
}
oraAllInOne->blob = 0;
if (isError)
{
if (!isKeepPartial)
Rm(oraAllInOne, pDirectory, pRemoteFile);
ExitWithError(oraAllInOne, RET_ORA, ERROR_NONE, 0);
}
}
OclBM::OclBM(int width,int height,int numofdisps,int win){
edge_method = HAS_EDGE;
maxZ = 3.0;
cv::Mat_<double> cameraMatrix1(3,3);
cameraMatrix1<< 583.41225, 0. , 326.75770,
0. , 589.27674, 209.41198,
0. , 0. , 1.;
cv::Mat_<double> disCoeff1(5,1);
disCoeff1<<-0.00404, -0.14885, -0.00176, 0.00102, 0.00000;
cv::Mat_<double> cameraMatrix2(3,3);
cameraMatrix2<< 579.99012, 0. , 317.64133,
0. , 585.44507, 219.48944,
0. , 0. , 1.;
cv::Mat_<double> disCoeff2(5,1);
disCoeff2<<0.00698, -0.16722, -0.00279, 0.00162, 0.00000;
cv::Mat_<double> rm(3,1);
rm<<0.01857, 0.00525, -0.03124;
cv::Mat_<double> Rm(3,3);
cv::Rodrigues(rm, Rm);
// Rm<< 9.9949590888302986e-01, 3.0555658693688051e-02, 8.6185757455006194e-03,
// -3.0365830270320297e-02, 9.9931064739905584e-01, -2.1357582889317616e-02,
// -9.2652295211821528e-03, 2.1085106513243395e-02, 9.9973475172429860e-01;
cv::Mat_<double> Tv(3,1);
Tv<<-80.14897, 1.97999, -1.23445;
cv::Mat Rr1,Rr2,Pr1,Pr2;
cv::Rect roi1,roi2;
cv::stereoRectify(cameraMatrix1, disCoeff1, cameraMatrix2, disCoeff2, cv::Size(width,height), Rm, Tv, Rr1, Rr2, Pr1, Pr2, Qw);
LOGI("Rr1: %f, %f, %f, %f, %f, %f, %f, %f, %f", Rr1.at<double>(0,0), Rr1.at<double>(0,1), Rr1.at<double>(0,2),
Rr1.at<double>(1,0), Rr1.at<double>(1,1), Rr1.at<double>(1,2), Rr1.at<double>(2,0), Rr1.at<double>(2,1), Rr1.at<double>(2,2));
LOGI("Rr2: %f, %f, %f, %f, %f, %f, %f, %f, %f", Rr2.at<double>(0,0), Rr2.at<double>(0,1), Rr2.at<double>(0,2),
Rr2.at<double>(1,0), Rr2.at<double>(1,1), Rr2.at<double>(1,2), Rr2.at<double>(2,0), Rr2.at<double>(2,1), Rr2.at<double>(2,2));
LOGI("Pr1: %f, %f, %f, %f, %f, %f, %f, %f, %f", Pr1.at<double>(0,0), Pr1.at<double>(0,1), Pr1.at<double>(0,2),
Pr1.at<double>(1,0), Pr1.at<double>(1,1), Pr1.at<double>(1,2), Pr1.at<double>(2,0), Pr1.at<double>(2,1), Pr1.at<double>(2,2));
LOGI("Pr2: %f, %f, %f, %f, %f, %f, %f, %f, %f", Pr2.at<double>(0,0), Pr2.at<double>(0,1), Pr2.at<double>(0,2),
Pr2.at<double>(1,0), Pr2.at<double>(1,1), Rr2.at<double>(1,2), Pr2.at<double>(2,0), Pr2.at<double>(2,1), Pr2.at<double>(2,2));
LOGI("Qw: \n%f, %f, %f, %f,\n%f, %f, %f, %f,\n%f, %f, %f, %f,\n%f, %f, %f, %f",
Qw.at<double>(0,0), Qw.at<double>(0,1), Qw.at<double>(0,2), Qw.at<double>(0,3),
Qw.at<double>(1,0), Qw.at<double>(1,1), Qw.at<double>(1,2), Qw.at<double>(1,3),
Qw.at<double>(2,0), Qw.at<double>(2,1), Qw.at<double>(2,2), Qw.at<double>(2,3),
Qw.at<double>(3,0), Qw.at<double>(3,1), Qw.at<double>(3,2), Qw.at<double>(3,3));
LOGI("Center difference: %f", -Qw.at<double>(3,3)/Qw.at<double>(3,2));
cv::initUndistortRectifyMap(cameraMatrix1, disCoeff1, Rr1, Pr1, cv::Size(width,height), CV_16SC2, mapx1, mapy1);
cv::initUndistortRectifyMap(cameraMatrix2, disCoeff2, Rr2, Pr2, cv::Size(width,height), CV_16SC2, mapx2, mapy2);
// create images for processing
imgWidth=width;
imgHeight=height;
dispImg.create(height,2*width,CV_8UC4);
depthMatrix.create(height,width,CV_32FC3);
ndisp=numofdisps;
winSize=win;
/*
// output gpu device information
cv::ocl::DevicesInfo devInfo;
int res=cv::ocl::getOpenCLDevices(devInfo);
if(res==0){
LOGE("There is no OpenCL here!");
}else{
for(int i=0;i<devInfo.size();++i){
LOGI("deviceProfile: %s",devInfo[i]->deviceProfile.c_str());
LOGI("deviceVersion: %s",devInfo[i]->deviceVersion.c_str());
LOGI("deviceName: %s",devInfo[i]->deviceName.c_str());
LOGI("deviceVendor: %s",devInfo[i]->deviceVendor.c_str());
LOGI("deviceDriverVersion: %s",devInfo[i]->deviceDriverVersion.c_str());
LOGI("deviceExtensions: %s",devInfo[i]->deviceExtensions.c_str());
LOGI("maxWorkGroupSize: %d",devInfo[i]->maxWorkGroupSize);
LOGI("maxComputeUnits: %d",devInfo[i]->maxComputeUnits);
LOGI("localMemorySize: %d",devInfo[i]->localMemorySize);
LOGI("maxMemAllocSize: %d",devInfo[i]->maxMemAllocSize);
LOGI("deviceVersionMajor: %d",devInfo[i]->deviceVersionMajor);
LOGI("deviceVersionMinor: %d",devInfo[i]->deviceVersionMinor);
}
}
*/
#ifdef DUMP_DEPTH
dumpCount = 0;
#endif
}