double estimate_image_blur(const cv::Mat &image, const std::vector<std::array<std::array<long, 2>, 68>> &landmarks){
long num_rows = image.dims[0];
long num_cols = image.dims[1];
long num_pixels = num_rows * num_cols;
cv::Mat image_gray;
cv::cvCvtColor(image, image_gray, CV_RGB2GRAY);
cv::Mat image_gray_equalized = image_gray
std::vector<std::vector<float>> mask_face_outine = find_face(image, landmarks);
cv::Ptr<cv::CLAHE> clahe = cv::createCLAHE(double clipLimit = 0.01, cv::Size tileGridSize=cv::Size(8,8));
clahe->apply(image_gray, image_gray_equalized);
for(int i=0; i<image_gray_equalized.rows; i++){
for(int j=0; j<image_gray_equalized.cols; j++){
image_gray_equalized.at<uchar>(i,j) = image_gray_equalized.at<uchar>(i,j) * mask_face_outine[i][j];
};
};
cv::GaussianBlur( image_gray_equalized, image_gray_equalized, Size(3,3), 0, 0, cv::BORDER_DEFAULT);
double max_val = max_of_cvmat(image_gray_equalized);
double blur_metric = 1.0 - (0.5 + std::exp(std::log(0.4) - 0.85 * max_val));
return blur_metric;
};
void TopologyInfo::find_side( EntityTopology topo,
const unsigned* side_vertices,
unsigned num_vertices,
unsigned& dimension_out,
unsigned& number_out,
bool& reversed_out,
MsqError& err )
{
switch (num_vertices) {
case 1:
dimension_out = 0;
number_out = *side_vertices;
reversed_out = false;
if (*side_vertices >= corners(topo))
MSQ_SETERR(err)(MsqError::INVALID_ARG,"Invalid corner number: %u\n", *side_vertices);
break;
case 2:
dimension_out = 1;
number_out = find_edge( topo, side_vertices, reversed_out, err );
MSQ_CHKERR(err);
break;
case 3:
case 4:
dimension_out = 2;
number_out = find_face( topo, side_vertices, num_vertices, reversed_out, err );
MSQ_CHKERR(err);
break;
default:
MSQ_SETERR(err)(MsqError::UNSUPPORTED_ELEMENT, "Invalid number of side vertices: %u\n", num_vertices );
break;
}
}
//------------------------------------------------------------------------
bool font_engine_freetype_base::load_font(const char* font_name,
unsigned face_index,
glyph_rendering ren_type,
const char* font_mem,
const long font_mem_size)
{
bool ret = false;
if(m_library_initialized)
{
m_last_error = 0;
int idx = find_face(font_name);
if(idx >= 0)
{
m_cur_face = m_faces[idx];
m_name = m_face_names[idx];
}
else
{
if(m_num_faces >= m_max_faces)
{
delete [] m_face_names[0];
FT_Done_Face(m_faces[0]);
memcpy(m_faces,
m_faces + 1,
(m_max_faces - 1) * sizeof(FT_Face));
memcpy(m_face_names,
m_face_names + 1,
(m_max_faces - 1) * sizeof(char*));
m_num_faces = m_max_faces - 1;
}
if (font_mem && font_mem_size)
{
m_last_error = FT_New_Memory_Face(m_library,
(const FT_Byte*)font_mem,
font_mem_size,
face_index,
&m_faces[m_num_faces]);
}
else
{
m_last_error = FT_New_Face(m_library,
font_name,
face_index,
&m_faces[m_num_faces]);
}
if(m_last_error == 0)
{
m_face_names[m_num_faces] = new char [strlen(font_name) + 1];
strcpy(m_face_names[m_num_faces], font_name);
m_cur_face = m_faces[m_num_faces];
m_name = m_face_names[m_num_faces];
++m_num_faces;
}
else
{
m_face_names[m_num_faces] = 0;
m_cur_face = 0;
m_name = 0;
}
}
if(m_last_error == 0)
{
ret = true;
switch(ren_type)
{
case glyph_ren_native_mono:
m_glyph_rendering = glyph_ren_native_mono;
break;
case glyph_ren_native_gray8:
m_glyph_rendering = glyph_ren_native_gray8;
break;
case glyph_ren_outline:
if(FT_IS_SCALABLE(m_cur_face))
{
m_glyph_rendering = glyph_ren_outline;
}
else
{
m_glyph_rendering = glyph_ren_native_gray8;
}
break;
case glyph_ren_agg_mono:
if(FT_IS_SCALABLE(m_cur_face))
{
m_glyph_rendering = glyph_ren_agg_mono;
}
else
{
m_glyph_rendering = glyph_ren_native_mono;
}
break;
case glyph_ren_agg_gray8:
if(FT_IS_SCALABLE(m_cur_face))
{
m_glyph_rendering = glyph_ren_agg_gray8;
}
else
{
m_glyph_rendering = glyph_ren_native_gray8;
}
break;
}
update_signature();
}
}
return ret;
}
