void Controller::openFile(QString filename){
Parameters params;
qDebug() << "Open parameters window";
if(params.exec()==true)
{
qDebug() << "Starting row:" << params.getStartingRow();
qDebug() << "Starting column:" << params.getStartingColumn();
qDebug() << "Ending column:" << params.getEndingColumn();
qDebug() << "Read file: " << filename.toLocal8Bit().constData();
this->addFileToRecentlyOpen(filename);
QFile file(filename);
DataImport di(params.getStartingRow() - 1, params.getStartingColumn() - 1, params.getEndingColumn() - 1);
Mat pcaInputData = di.parseData(file);
bool success = pcaInputData.rows > 0;
if(!success){
qDebug() << "Error in: " << filename;
return;
}
qDebug() << "Import status: " << success;
MicroMatrixPCA pca(pcaInputData);
Mat pca_pro = pca.projectAll();
saveMat("pca.txt", pca_pro);
Mat pca_backpro = pca.backProjectAll(100);
saveMat("pca_back.txt", pca_backpro);
QMap<int, float> map=pca.calculateErrors();
PCAResultWindow *errorWindow = new PCAResultWindow(NULL, map);
errorWindow->show();
this->importedDataModel->addImportedFile(filename, pcaInputData.rows, pcaInputData.cols);
}
}
int ns__bitwiseAnd( struct soap *soap, char *src1,
char *src2,
char **OutputMatFilename)
{
double start, end;
start = omp_get_wtime();
Mat matSrc1;
if(!readMat(src1, matSrc1))
{
cerr << "And :: src1 can not read bin file" << endl;
return soap_receiver_fault(soap, "And :: src1 can not read bin file", NULL);
}
Mat matSrc2;
if(!readMat(src2, matSrc2))
{
cerr << "And :: src2 can not read bin file" << endl;
return soap_receiver_fault(soap, "And :: src2 can not read bin file", NULL);
}
int cols = matSrc1.cols ;
int srcType1 = matSrc1.type();
int srcType2 = matSrc2.type();
if(srcType1 != srcType2 )
{
matSrc2.convertTo(matSrc2, srcType1);
}
Mat dst;
bitwise_and(matSrc1, matSrc2, dst);
/* generate output file name */
*OutputMatFilename = (char*)soap_malloc(soap, 60);
getOutputFilename(OutputMatFilename,"_bitwiseAnd");
/* save to bin */
if(!saveMat(*OutputMatFilename, dst))
{
cerr << "And:: save mat to binary file" << endl;
return soap_receiver_fault(soap, "And :: save mat to binary file", NULL);
}
matSrc1.release();
matSrc2.release();
dst.release();
end = omp_get_wtime();
cerr<<"ns__And time elapsed "<<end-start<<endl;
return SOAP_OK;
}
int main()
{
const IplImage* im1 = cvLoadImage("302.png",0);
const IplImage* im2 = cvLoadImage("303.png",0);
//int w_s = 10;
int w = im1->width;
int h = im1->height;
//printf("Width = %d\nHeight = %d\n",w,h);
CvMat* vel = cvCreateMat(h,w,CV_32FC2);
CvMat* velx = cvCreateMat(h,w,CV_32FC1);
CvMat* vely = cvCreateMat(h,w,CV_32FC1);
CvMat* u = cvCreateMat(h/10, w/10, CV_32FC1); // Averaged Optical flows
CvMat* v = cvCreateMat(h/10, w/10, CV_32FC1);
//printf("matDimU = %d %d\nMatDimVel = %d %d\n ",cvGetMatSize(u),cvGetMatSize(velx));
//printf("Ptr = %d %d \n",im1->data.ptr,velx->data.ptr);
//cvCalcOpticalFlowLK(im1,im2,cvSize(4,4),velx,vely);
//cvCalcOpticalFlowFarneback(const CvArr* prev, const CvArr* next, CvArr* flow,
// double pyr_scale, int levels, int winsize, int iterations, int poly_n, double poly_sigma, int flags) flag means to use Gaussian smoothing
cvCalcOpticalFlowFarneback(im1, im2, vel,0.5, 1, 2, 2, 2, 0.17, 0);//, iterations, poly_n, poly_sigma
cvSplit(vel, velx, vely, NULL, NULL);
average_flow(velx, u);
average_flow(vely, v);
/*//cvSave("u.xml", u);
//cvSave("v.xml", v);*/
saveMat(u,"ux.m");
saveMat(v,"vy.m");
/* CvMat* Big = cvCreateMat(50,50,CV_32FC1);
cvSetIdentity(Big);
CvMat* small = cvCreateMat(5,5,CV_32FC1);
average_flow(Big,small);
printMat(small);*/
return 0;
}
int ns__dilate( struct soap *soap, char *InputMatFilename,
char *elementFilename,
int iteration=1,
char **OutputMatFilename=NULL)
{
double start, end;
start = omp_get_wtime();
Mat src;
if(!readMat(InputMatFilename, src))
{
cerr << "dilate :: can not read bin file" << endl;
return soap_receiver_fault(soap, "dilate :: can not read bin file", NULL);
}
Mat dst;
Mat element;
if(!readMat(elementFilename, element))
{
cerr<<"dilate :: use default element"<<endl;
element.release();
dilate(src, dst, Mat(), Point(-1, -1), iteration);
} else {
cerr<<"dilate :: use defined element"<<endl;
dilate(src, dst, element, Point(-1, -1), iteration);
}
/* generate output file name */
*OutputMatFilename = (char*)soap_malloc(soap, 60);
getOutputFilename(OutputMatFilename,"_dilate");
/* save to bin */
if(!saveMat(*OutputMatFilename, dst))
{
cerr << "dilate :: save mat to binary file" << endl;
return soap_receiver_fault(soap, "dilate :: save mat to binary file", NULL);
}
src.release();
dst.release();
element.release();
return SOAP_OK;
}
MatWindow::MatWindow(QWidget *parent)
: QWidget(parent)
{
setWindowTitle(tr("View/Change Material"));
setWindowFlags(Qt::Dialog);
setMinimumSize(QSize(400, 500));
setMaximumSize(QSize(400, 500));
treeMat = new QTreeWidget(this);
treeMat->setHeaderLabels(QStringList("Sub Entities"));
treeMat->setMinimumSize(150, 150);
connect(treeMat, SIGNAL(itemClicked(QTreeWidgetItem*, int)), this, SLOT(processMat(QTreeWidgetItem*)));
textureLbl = new QLabel("Texture Preview");
textureLbl->setPixmap(tr("settings.png"));
textureLbl->setMinimumSize(150, 150);
matText = new QTextEdit;
matText->setMinimumSize(300, 200);
connect(matText, SIGNAL(textChanged()), this, SLOT(updateTexture()));
//Textures
viewTexture = new QGroupBox(tr("View Texture"));
treeTextureLayout = new QHBoxLayout;
treeTextureLayout->addWidget(treeMat);
treeTextureLayout->addWidget(textureLbl);
viewTexture->setLayout(treeTextureLayout);
//////////
//Material
viewMat = new QGroupBox(tr("View Material"));
matLayout = new QVBoxLayout;
matLayout->addWidget(matText);
viewMat->setLayout(matLayout);
////////////
//Btn
groupBtn = new QGroupBox;
groupBtn->setFlat(true);
okBtn = new QPushButton(tr("&Ok"));
okBtn->setMaximumSize(QSize(75, 25));
connect(okBtn, SIGNAL(clicked()), this, SLOT(saveMat()));
cancelBtn = new QPushButton(tr("&Cancel"));
cancelBtn->setMaximumSize(QSize(75, 25));
connect(cancelBtn, SIGNAL(clicked()), this, SLOT(close()));
btnLayout = new QGridLayout;
btnLayout->addWidget(okBtn, 0, 1);
btnLayout->addWidget(cancelBtn, 0, 2);
btnLayout->setAlignment(okBtn, Qt::AlignRight & Qt::AlignBottom);
btnLayout->setAlignment(cancelBtn, Qt::AlignRight & Qt::AlignBottom);
groupBtn->setLayout(btnLayout);
///////////
gridLayout = new QVBoxLayout;
gridLayout->addWidget(viewTexture);
gridLayout->addWidget(viewMat);
gridLayout->addWidget(groupBtn);
setLayout(gridLayout);
scriptPath += QDir::currentPath()+"/media/materials/scripts/";
texturePath += QDir::currentPath()+"/media/materials/textures/";
posMat = -1;
nextMat = -1;
strAllMat = "";
}
//*
// Get Covariance Matrix of L0 feature
int main(int argc, char** argv)
{
std::string in_path("UW_new_dict");
//std::string in_path("BB_new_dict");
int KK = 128;
int T = 10;
pcl::console::parse_argument(argc, argv, "--K", KK);
pcl::console::parse_argument(argc, argv, "--t", T);
std::ostringstream ss;
ss << KK;
{
cv::Mat depth_xyz_center, depth_xyz_range;
readMat(in_path+"/depth_xyz_center.cvmat", depth_xyz_center);
readMat(in_path+"/depth_xyz_range.cvmat", depth_xyz_range);
std::cerr << depth_xyz_center.rows << std::endl;
depth_xyz_range = depth_xyz_range.mul(depth_xyz_range);
WKmeans depth_clusterer;
depth_clusterer.AddData(depth_xyz_center, depth_xyz_range);
cv::Mat refined_depth_xyz_center;
depth_clusterer.W_Cluster(refined_depth_xyz_center, KK, T);
saveMat(in_path+"/refined_depth_xyz_center_"+ss.str()+".cvmat", refined_depth_xyz_center);
}
{
cv::Mat depth_lab_center, depth_lab_range;
readMat(in_path+"/depth_lab_center.cvmat", depth_lab_center);
readMat(in_path+"/depth_lab_range.cvmat", depth_lab_range);
std::cerr << depth_lab_center.rows << std::endl;
depth_lab_range = depth_lab_range.mul(depth_lab_range);
WKmeans depth_clusterer;
depth_clusterer.AddData(depth_lab_center, depth_lab_range);
cv::Mat refined_depth_lab_center;
depth_clusterer.W_Cluster(refined_depth_lab_center, KK, T);
saveMat(in_path+"/refined_depth_lab_center_"+ss.str()+".cvmat", refined_depth_lab_center);
}
{
cv::Mat color_xyz_center, color_xyz_range;
readMat(in_path+"/color_xyz_center.cvmat", color_xyz_center);
readMat(in_path+"/color_xyz_range.cvmat", color_xyz_range);
std::cerr << color_xyz_center.rows << std::endl;
color_xyz_range = color_xyz_range.mul(color_xyz_range);
WKmeans color_clusterer;
color_clusterer.AddData(color_xyz_center, color_xyz_range);
cv::Mat refined_color_xyz_center;
color_clusterer.W_Cluster(refined_color_xyz_center, KK, T);
saveMat(in_path+"/refined_color_xyz_center_"+ss.str()+".cvmat", refined_color_xyz_center);
}
{
cv::Mat color_lab_center, color_lab_range;
readMat(in_path+"/color_lab_center.cvmat", color_lab_center);
readMat(in_path+"/color_lab_range.cvmat", color_lab_range);
std::cerr << color_lab_center.rows << std::endl;
color_lab_range = color_lab_range.mul(color_lab_range);
WKmeans color_clusterer;
color_clusterer.AddData(color_lab_center, color_lab_range);
cv::Mat refined_color_lab_center;
color_clusterer.W_Cluster(refined_color_lab_center, KK, T);
saveMat(in_path+"/refined_color_lab_center_"+ss.str()+".cvmat", refined_color_lab_center);
}
return 1;
}
int main(int argc, const char *argv[])
{
// parse arguments ///////////////////////////////////////////
// Declare the supported options.
po::options_description desc("Visualize data");
desc.add_options()
("help", "produce help message")
("width", po::value<double>()->required(), "Width ")
("height", po::value<double>()->required(), "Height ")
("dir", po::value<std::string>()->default_value("."), "Data directory")
;
po::positional_options_description pos;
pos.add("width", 1);
pos.add("height", 1);
pos.add("dir", 1);
po::variables_map vm;
po::store(po::command_line_parser(argc, argv).options(desc).positional(pos).run(), vm);
po::notify(vm);
double width = vm["width"].as<double>();
double height = vm["height"].as<double>();
std::string datadirectory = vm["dir"].as<std::string>();
// end of parse arguments ////////////////////////////////////
cv::Mat laser_pose, laser_ranges, scan_angles;
loadMat(laser_pose, datadirectory + "/laser_pose_all.bin");
loadMat(laser_ranges, datadirectory + "/laser_range_all.bin");
loadMat(scan_angles, datadirectory + "/scan_angles_all.bin");
cv::Mat laser_reflectance(laser_ranges.rows, laser_ranges.cols, CV_8U);
std::string floorplanfile = datadirectory + "/floorplan.png";
cv::Mat floorplan = cv::imread(floorplanfile, cv::IMREAD_GRAYSCALE);
if(! floorplan.data ) // Check for invalid input
{
std::cout << "Could not open or find the image" << std::endl ;
return -1;
}
cv::transpose(floorplan, floorplan);
cv::flip(floorplan, floorplan, 1);
cv::Vec2d size_bitmap(width, height);
cv::Vec2d margin(1, 1);
cv::Vec2d min_pt(- margin(0) - size_bitmap(0)/2, - margin(1) - size_bitmap(1)/2);
double max_range = 8;
cv::Vec2i gridsize(floorplan.size[0], floorplan.size[1]);
cv::Vec2d cellsize;
cv::divide(size_bitmap , gridsize, cellsize);
//std::cout << cellsize(0) << cellsize(1) << std::endl;
cv::Vec2i ncells;
cv::divide(min_pt, cellsize, ncells, -2);
OccupancyGrid2D<double, int> map(
min_pt(0),
min_pt(1),
cellsize(0),
cellsize(1),
ncells(0),
ncells(1));
// initialize map with occupancy with floorplan
for (int r = 0; r < ncells(0); ++r) {
for (int c = 0; c < ncells(1); ++c) {
int fp_r = r - margin(0) / cellsize(0);
int fp_c = c - margin(1) / cellsize(1);
if ((0 <= fp_r) && (fp_r < floorplan.rows)
&& (0 <= fp_c) && (fp_c < floorplan.cols)) {
map.og_.at<uint8_t>(r, c) = (floorplan.at<uint8_t>(fp_r, fp_c) > 127) ? map.FREE : map.OCCUPIED;
} else {
map.og_.at<uint8_t>(r, c) = map.OCCUPIED;
}
}
}
boost::mt19937 gen;
boost::normal_distribution<> norm_dist(1, NOISE_VARIANCE);
boost::variate_generator<boost::mt19937&, boost::normal_distribution<> > norm_rand(gen, norm_dist);
for (int r = 0; r < scan_angles.rows; r++) {
double* pose = laser_pose.ptr<double>(r);
double* angles = scan_angles.ptr<double>(r);
double robot_angle = pose[2];
for (int c = 0; c < scan_angles.cols; c++) {
double total_angle = robot_angle + angles[c];
cv::Vec2d final_pos;
bool refl;
double range = map.ray_trace(pose[0], pose[1], total_angle, max_range, final_pos, refl);
range *= norm_rand();
laser_ranges.at<double>(r, c) = range;
laser_reflectance.at<uint8_t>(r, c) = (uint8_t) refl;
}
// draw input
cv::Mat visin;
cv::cvtColor(map.og_, visin, cv::COLOR_GRAY2BGR);
cv::Vec2d position(pose[0], pose[1]);
map.draw_lasers(visin, position, robot_angle, angles,
laser_ranges.ptr<double>(r),
laser_reflectance.ptr<uint8_t>(r),
scan_angles.cols,
CV_RGB(0, 255, 0));
cv::imshow("c", visin);
cv::waitKey(33);
}
saveMat(laser_ranges, "laser_range_all.bin");
saveMat(laser_reflectance, "laser_reflectance_all.bin");
}
void StereoCapturer::computeStereo(float dt, bool display, bool save_Rectified){
double min, max;
cv::Mat imgD,imgD2;
int i,w,h;
char buffer[255];
if(intrinsics.empty()||extrinsics.empty()){
cerr<< "Missing intrinsic and extrinsic file, file paths required at constructor"<<endl;
return;
}
while(true){
if(current > finish){
cout<<"End of frames"<<endl;
return;
}
sprintf(buffer,"%s%i.%s",loadS1.data(),current,ext1.data());
imgLeft = cv::imread(buffer,0); //left Image
if(imgLeft.data == NULL){
cout<< "image "<< buffer<<" not found"<<endl;
return;
}
sprintf(buffer,"%s%i.%s",loadS2.data(),current,ext2.data());
imgRight = cv::imread(buffer,0); //Right Image
if(imgRight.data == NULL){
cout<< "image "<< buffer<<" not found"<<endl;
return;
}
cout<<"Read image "<<loadS1.data()<<current<<endl;
boost::posix_time::ptime startTime, stopTime;
startTime = boost::posix_time::microsec_clock::local_time();
computeDisparity(imgDepth);
stopTime = boost::posix_time::microsec_clock::local_time();
boost::posix_time::time_duration dur = stopTime - startTime;
double milliseconds = dur.total_milliseconds();
cout<<"Time Passed "<<milliseconds<<" Milli seconds"<<endl;
cout<<(int)imgDepth.step1(1)<<endl;
cv::minMaxIdx(imgDepth, &min, &max);
cout<<min<<" "<<max<<endl;
cout<<255 / (max-min)<<endl;
cv::normalize(imgDepth,imgD,0, 255,NORM_MINMAX,CV_8UC1);
cv::minMaxIdx(imgD, &min, &max);
cout<<min<<" "<<max<<endl;
sprintf(buffer,"disparity/depthImage%i.png",current);
imwrite(buffer,imgD); //Viewing purposes
sprintf(buffer,"disparity/depthImage%i.DMX",current);
saveMat(imgDepth,buffer,dt); //Processing purposes
if(save_Rectified)
{
sprintf(buffer,"%sRectified%i.png",loadS1.data(),current);
imwrite(buffer,imgLeftr);
sprintf(buffer,"%sRectified%i.png",loadS2.data(),current);
imwrite(buffer,imgRight);
}
if(display){
w = imgRightr.size().width;
h = imgRightr.size().height;
Mat canvas;
Mat tImage;
canvas.create(h, w*2, CV_8UC3);
Mat canvasPart = canvas(Rect(0, 0, w, h));
cvtColor(imgLeftr, tImage, COLOR_GRAY2BGR);
resize(tImage, canvasPart, canvasPart.size(), 0, 0, CV_INTER_AREA);
Rect vroil(cvRound(roi1.x), cvRound(roi1.y),
cvRound(roi1.width), cvRound(roi1.height));
rectangle(canvasPart, vroil, Scalar(0,0,255), 3, 8);
canvasPart = canvas(Rect(w, 0, w, h));
cvtColor(imgRightr, tImage, COLOR_GRAY2BGR);
resize(tImage, canvasPart, canvasPart.size(), 0, 0, CV_INTER_AREA);
Rect vroir(cvRound(roi2.x), cvRound(roi2.y),
cvRound(roi2.width), cvRound(roi2.height));
rectangle(canvasPart, vroir, Scalar(0,0,255), 3, 8);
for( i = 0; i < canvas.rows; i += 16 )
line(canvas, Point(0, i), Point(canvas.cols, i), Scalar(0, 255, 0), 1, 8);
// imshow("left Image",imgLeftr);
// imshow("right Image", imgRightr);
imshow("Rectified Images",canvas);
imshow("Depth image",imgD);
waitKey(0);
}
current++;
}
}
int ns__trainANN(struct soap *soap,
char *inputMatFilename,
char *neuralFile,
char **OutputMatFilename)
{
double start, end;
start = omp_get_wtime();
Mat src; //must be 3ch image
if(!readMat(inputMatFilename, src))
{
cerr << "trainANN :: can not read bin file" << endl;
soap->fault->faultstring = "trainANN :: can not read bin file";
return SOAP_FAULT;
}
// convert src to CvMat to use an old-school function
CvMat tmp = src;
CV_Assert(tmp.cols == src.cols && tmp.rows == src.rows &&
tmp.data.ptr == (uchar*)src.data && tmp.step == src.step);
CvMat *input3Ch = cvCreateMat(src.rows, src.cols, CV_32FC3);
cvConvert(&tmp, input3Ch);
CvMat *output1Ch = cvCreateMat(src.rows, src.cols, CV_32FC1);
CvANN_MLP* neuron = NULL ;
if (neuron == NULL )
neuron = new CvANN_MLP();
else
neuron->clear();
if(!ByteArrayToANN(neuralFile, neuron)){
cerr << "trainANN :: can not load byte array to neural" << endl;
return soap_receiver_fault(soap, "trainANN :: can not load byte array to neural", NULL);
}
CvMat input_nn = cvMat(input3Ch->height*input3Ch->width, 3, CV_32FC1, input3Ch->data.fl);
CvMat output_nn = cvMat(output1Ch->height*output1Ch->width, 1, CV_32FC1, output1Ch->data.fl);
neuron->predict(&input_nn, &output_nn);
Mat resultNN = cvarrToMat(output1Ch, false);
/* generate output file name */
*OutputMatFilename = (char*)soap_malloc(soap, FILENAME_SIZE);
time_t now = time(0);
strftime(*OutputMatFilename, sizeof(OutputMatFilename)*FILENAME_SIZE, "/home/lluu/dir/%Y%m%d_%H%M%S_trainANN", localtime(&now));
/* save to bin */
if(!saveMat(*OutputMatFilename, resultNN))
{
cerr << "trainANN :: save mat to binary file" << endl;
return soap_receiver_fault(soap, "trainANN :: save mat to binary file", NULL);
}
src.release();
resultNN.release();
cvReleaseMat(&output1Ch);
end = omp_get_wtime();
cerr<<"ns__trainANN "<<"time elapsed "<<end-start<<endl;
return SOAP_OK;
}
