mat utils::load_matrix(string file_path, int xdim, int ydim){
mat tmp_mat = randu<mat>(xdim+1, ydim);
FILE * fin = fopen(file_path.c_str(), "r");
if (!fin) {
printf("Can't open file %s to read!", file_path.c_str());
exit(1);
}
int xidx=0;
char buff[BUFF_SIZE_LONG];
while (fgets(buff, BUFF_SIZE_LONG-1, fin) != NULL){
vector<char *> line_segments = split_str(buff, ' ');
if (line_segments.size() != (unsigned int)ydim){
printf("Dimension of latent factor can't match with model's.\n");
exit(1);
}
for (unsigned int i=0; i<line_segments.size(); i++)
tmp_mat(xidx+1, i) = atof(line_segments[i]);
xidx++;
memset(buff, 0, BUFF_SIZE_LONG);
}
if (xidx != xdim){
cout << "read number of user:"******"original number of user:"******"Number of rows can't match.\n");
exit(1);
}
return tmp_mat;
}
NOX::Abstract::Group::ReturnType
LOCA::Hopf::MinimallyAugmented::Constraint::
computeDOmega(NOX::Abstract::MultiVector::DenseMatrix& domega)
{
string callingFunction =
"LOCA::Hopf::MinimallyAugmented::Constraint::computeDOmega()";
NOX::Abstract::Group::ReturnType status;
NOX::Abstract::Group::ReturnType finalStatus = NOX::Abstract::Group::Ok;
// Compute sigma, w and v if necessary
if (!isValidConstraints) {
status = computeConstraints();
finalStatus =
globalData->locaErrorCheck->combineAndCheckReturnTypes(status,
finalStatus,
callingFunction);
}
// Compute mass matrix M
status = grpPtr->computeShiftedMatrix(0.0, 1.0);
finalStatus =
globalData->locaErrorCheck->combineAndCheckReturnTypes(status,
finalStatus,
callingFunction);
// Compute M*v
Teuchos::RCP<NOX::Abstract::MultiVector> tmp_vector =
v_vector->clone(NOX::ShapeCopy);
status = grpPtr->applyShiftedMatrixMultiVector(*v_vector, *tmp_vector);
finalStatus =
globalData->locaErrorCheck->combineAndCheckReturnTypes(status,
finalStatus,
callingFunction);
// Compute u^T*M*v
NOX::Abstract::MultiVector::DenseMatrix tmp_mat(2,2);
tmp_vector->multiply(1.0, *w_vector, tmp_mat);
// Compute domega
domega(0,0) = tmp_mat(0,1) - tmp_mat(1,0);
domega(1,0) = -(tmp_mat(0,0) + tmp_mat(1,1));
domega.scale(1.0/sigma_scale);
return finalStatus;
}
CalibrationParams
CalibrationParams::createCalibrationParams(std::string serial, cv::FileNode node) {
cv::Mat camera_matrix (cv::Mat::eye(3, 3, CV_64FC1));
cv::Mat dist_coeffs (5, 1, CV_64FC1, cv::Scalar::all(0));
cv::Mat r_mat (3, 3, CV_64FC1, cv::Scalar::all(0));
cv::Mat t (3, 1, CV_64FC1, cv::Scalar::all(0));
node["camera_matrix"] >> camera_matrix;
node["distortion_coefficients"] >> dist_coeffs;
node["rotation"] >> r_mat;
node["translation"] >> t;
float fx = camera_matrix.ptr<double>(0)[0];
float fy = camera_matrix.ptr<double>(0)[4];
float cx = camera_matrix.ptr<double>(0)[2];
float cy = camera_matrix.ptr<double>(0)[5];
Eigen::Matrix4f tmp_mat = Eigen::Matrix4f::Identity();
for (int i = 0; i < 3; i++) {
for (int j = 0; j < 3; j++) {
tmp_mat(i, j) = r_mat.at<double>(i, j);
}
}
for (int i = 0; i < 3; i++) {
tmp_mat(i, 3) = t.at<double>(i);
}
return {
serial,
camera_matrix,
dist_coeffs,
r_mat,
t,
tmp_mat.inverse(),
fx,
fy,
cx,
cy
};
}
int ImagePreProcess::ShowInvisibleImage(cv::Mat input_mat,int rows)
{
std::vector<std::string> window_name = {"1","2","3","4","5"};
for (int i = 0; i < input_mat.rows; i++)
{
cv::Mat tmp_mat(input_mat.cols,1,CV_32F);
input_mat.row(i).copyTo(tmp_mat);
tmp_mat = tmp_mat.reshape(0, rows);
cv::normalize(tmp_mat, tmp_mat, 1.0, 0.0, cv::NORM_MINMAX);
cv::Mat show_mat;
tmp_mat.convertTo(show_mat, CV_8UC1,255.0);
imshow(window_name[i],show_mat);
}
cv::waitKey(0);
return 0;
}
Matrix::Matrix (const ::VSMap &in, ::VSMap &out, void * /*user_data_ptr*/, ::VSCore &core, const ::VSAPI &vsapi)
: vsutl::FilterBase (vsapi, "matrix", ::fmParallel, 0)
, _clip_src_sptr (vsapi.propGetNode (&in, "clip", 0, 0), vsapi)
, _vi_in (*_vsapi.getVideoInfo (_clip_src_sptr.get ()))
, _vi_out (_vi_in)
, _sse_flag (false)
, _sse2_flag (false)
, _avx_flag (false)
, _avx2_flag (false)
, _range_set_src_flag (false)
, _range_set_dst_flag (false)
, _full_range_src_flag (false)
, _full_range_dst_flag (false)
/*, _mat_main ()*/
, _csp_out (fmtcl::ColorSpaceH265_UNSPECIFIED)
, _plane_out (get_arg_int (in, out, "singleout", -1))
, _proc_uptr ()
{
assert (&in != 0);
assert (&out != 0);
assert (&core != 0);
assert (&vsapi != 0);
vsutl::CpuOpt cpu_opt (*this, in, out);
_sse_flag = cpu_opt.has_sse ();
_sse2_flag = cpu_opt.has_sse2 ();
_avx_flag = cpu_opt.has_avx ();
_avx2_flag = cpu_opt.has_avx2 ();
_proc_uptr = std::unique_ptr <fmtcl::MatrixProc> (new fmtcl::MatrixProc (
_sse_flag, _sse2_flag, _avx_flag, _avx2_flag
));
// Checks the input clip
if (_vi_in.format == 0)
{
throw_inval_arg ("only constant pixel formats are supported.");
}
const ::VSFormat & fmt_src = *_vi_in.format;
if (fmt_src.subSamplingW != 0 || fmt_src.subSamplingH != 0)
{
throw_inval_arg ("input must be 4:4:4.");
}
if (fmt_src.numPlanes != NBR_PLANES)
{
throw_inval_arg ("greyscale format not supported as input.");
}
if ( ( fmt_src.sampleType == ::stInteger
&& ( fmt_src.bitsPerSample < 8
|| fmt_src.bitsPerSample > 12)
&& fmt_src.bitsPerSample != 16)
|| ( fmt_src.sampleType == ::stFloat
&& fmt_src.bitsPerSample != 32))
{
throw_inval_arg ("pixel bitdepth not supported.");
}
if (_plane_out >= NBR_PLANES)
{
throw_inval_arg (
"singleout is a plane index and must be -1 or ranging from 0 to 3."
);
}
// Destination colorspace
bool force_col_fam_flag;
const ::VSFormat * fmt_dst_ptr = get_output_colorspace (
in, out, core, fmt_src, _plane_out, force_col_fam_flag
);
if ( fmt_dst_ptr->colorFamily != ::cmGray
&& fmt_dst_ptr->colorFamily != ::cmRGB
&& fmt_dst_ptr->colorFamily != ::cmYUV
&& fmt_dst_ptr->colorFamily != ::cmYCoCg)
{
throw_inval_arg ("unsupported color family for output.");
}
if ( ( fmt_dst_ptr->sampleType == ::stInteger
&& ( fmt_dst_ptr->bitsPerSample < 8
|| fmt_dst_ptr->bitsPerSample > 12)
&& fmt_dst_ptr->bitsPerSample != 16)
|| ( fmt_dst_ptr->sampleType == ::stFloat
&& fmt_dst_ptr->bitsPerSample != 32))
{
throw_inval_arg ("output bitdepth not supported.");
}
if ( fmt_dst_ptr->sampleType != fmt_src.sampleType
|| fmt_dst_ptr->bitsPerSample < fmt_src.bitsPerSample
|| fmt_dst_ptr->subSamplingW != fmt_src.subSamplingW
|| fmt_dst_ptr->subSamplingH != fmt_src.subSamplingH)
{
throw_inval_arg (
"specified output colorspace is not compatible with the input."
);
}
// Preliminary matrix test: deduce the target color family if unspecified
if ( ! force_col_fam_flag
&& fmt_dst_ptr->colorFamily != ::cmGray)
{
int def_count = 0;
def_count += is_arg_defined (in, "mat" ) ? 1 : 0;
def_count += is_arg_defined (in, "mats") ? 1 : 0;
def_count += is_arg_defined (in, "matd") ? 1 : 0;
if (def_count == 1)
{
std::string tmp_mat (get_arg_str (in, out, "mat", ""));
tmp_mat = get_arg_str (in, out, "mats", tmp_mat);
tmp_mat = get_arg_str (in, out, "matd", tmp_mat);
fmtcl::ColorSpaceH265 tmp_csp =
find_cs_from_mat_str (*this, tmp_mat, false);
fmt_dst_ptr = find_dst_col_fam (tmp_csp, fmt_dst_ptr, fmt_src, core);
}
}
// Output format is validated.
_vi_out.format = fmt_dst_ptr;
const ::VSFormat &fmt_dst = *fmt_dst_ptr;
const int nbr_expected_coef = NBR_PLANES * (NBR_PLANES + 1);
bool mat_init_flag = false;
// Matrix presets
std::string mat (get_arg_str (in, out, "mat", ""));
std::string mats (( fmt_src.colorFamily == ::cmYUV ) ? mat : "");
std::string matd (( fmt_dst.colorFamily == ::cmYUV
|| fmt_dst.colorFamily == ::cmGray) ? mat : "");
mats = get_arg_str (in, out, "mats", mats);
matd = get_arg_str (in, out, "matd", matd);
if (! mats.empty () || ! matd.empty ())
{
fstb::conv_to_lower_case (mats);
fstb::conv_to_lower_case (matd);
select_def_mat (mats, fmt_src);
select_def_mat (matd, fmt_dst);
fmtcl::Mat4 m2s;
fmtcl::Mat4 m2d;
make_mat_from_str (m2s, mats, true);
make_mat_from_str (m2d, matd, false);
_csp_out = find_cs_from_mat_str (*this, matd, false);
_mat_main = m2d * m2s;
mat_init_flag = true;
}
// Range
_full_range_src_flag = (get_arg_int (
in, out, "fulls" ,
vsutl::is_full_range_default (fmt_src) ? 1 : 0,
0, &_range_set_src_flag
) != 0);
_full_range_dst_flag = (get_arg_int (
in, out, "fulld",
vsutl::is_full_range_default (fmt_dst) ? 1 : 0,
0, &_range_set_dst_flag
) != 0);
// Custom coefficients
const int nbr_coef = _vsapi.propNumElements (&in, "coef");
const bool custom_mat_flag = (nbr_coef > 0);
if (custom_mat_flag)
{
if (nbr_coef != nbr_expected_coef)
{
throw_inval_arg ("coef has a wrong number of elements.");
}
for (int y = 0; y < NBR_PLANES + 1; ++y)
{
for (int x = 0; x < NBR_PLANES + 1; ++x)
{
_mat_main [y] [x] = (x == y) ? 1 : 0;
if ( (x < fmt_src.numPlanes || x == NBR_PLANES)
&& y < fmt_dst.numPlanes)
{
int err = 0;
const int index = y * (fmt_src.numPlanes + 1) + x;
const double c = _vsapi.propGetFloat (&in, "coef", index, &err);
if (err != 0)
{
throw_rt_err ("error while reading the matrix coefficients.");
}
_mat_main [y] [x] = c;
}
}
}
mat_init_flag = true;
}
if (! mat_init_flag)
{
throw_inval_arg (
"you must specify a matrix preset or a custom coefficient list."
);
}
prepare_coef (fmt_dst, fmt_src);
if (_vsapi.getError (&out) != 0)
{
throw -1;
}
}
