jas_cmprof_t *jas_cmprof_createfromiccprof(jas_iccprof_t *iccprof)
{
jas_cmprof_t *prof;
jas_icchdr_t icchdr;
jas_cmpxformseq_t *fwdpxformseq;
jas_cmpxformseq_t *revpxformseq;
prof = 0;
fwdpxformseq = 0;
revpxformseq = 0;
if (!(prof = jas_cmprof_create()))
goto error;
jas_iccprof_gethdr(iccprof, &icchdr);
if (!(prof->iccprof = jas_iccprof_copy(iccprof)))
goto error;
prof->clrspc = icctoclrspc(icchdr.colorspc, 0);
prof->refclrspc = icctoclrspc(icchdr.refcolorspc, 1);
prof->numchans = jas_clrspc_numchans(prof->clrspc);
prof->numrefchans = jas_clrspc_numchans(prof->refclrspc);
if (prof->numchans == 1) {
if (mono(prof->iccprof, 0, &fwdpxformseq))
goto error;
if (mono(prof->iccprof, 1, &revpxformseq))
goto error;
} else if (prof->numchans == 3) {
if (triclr(prof->iccprof, 0, &fwdpxformseq))
goto error;
if (triclr(prof->iccprof, 1, &revpxformseq))
goto error;
}
prof->pxformseqs[SEQFWD(0)] = fwdpxformseq;
prof->pxformseqs[SEQREV(0)] = revpxformseq;
#if 0
if (prof->numchans > 1) {
lut(prof->iccprof, 0, PER, &pxformseq);
pxformseqs_set(prof, SEQFWD(PER), pxformseq);
lut(prof->iccprof, 1, PER, &pxformseq);
pxformseqs_set(prof, SEQREV(PER), pxformseq);
lut(prof->iccprof, 0, CLR, &pxformseq);
pxformseqs_set(prof, SEQREV(CLR), pxformseq);
lut(prof->iccprof, 1, CLR, &pxformseq);
pxformseqs_set(prof, SEQREV(CLR), pxformseq);
lut(prof->iccprof, 0, SAT, &pxformseq);
pxformseqs_set(prof, SEQREV(SAT), pxformseq);
lut(prof->iccprof, 1, SAT, &pxformseq);
pxformseqs_set(prof, SEQREV(SAT), pxformseq);
}
#endif
return prof;
error:
if (fwdpxformseq) {
jas_cmpxformseq_destroy(fwdpxformseq);
}
if (revpxformseq) {
jas_cmpxformseq_destroy(revpxformseq);
}
if (prof) {
jas_cmprof_destroy(prof);
}
return 0;
}
void LevelAnalyzedImage::analyze()
{
if ( inputImage_.empty() ) return;
cv::Mat grayImage;
{
std::lock_guard<std::mutex> lock(inputImageMutex_);
cv::cvtColor(inputImage_, grayImage, CV_BGR2GRAY);
}
// Noise reduction
cv::medianBlur(grayImage, grayImage, 5);
// Contrast collection
cv::Mat lut(1, 256, CV_8U);
for (int i = 0; i < 256; ++i) {
lut.at<unsigned char>(i) = (i < threshold_) ? (std::pow(i, 2) / threshold_) : (256 - std::pow(i, 2) / std::pow(256, 2));
// lut.at<unsigned char>(i) = 255 / (1 + std::exp(-contrast_ * (i - 128) / 255));
}
cv::LUT(grayImage, lut, grayImage);
// Check each cell color
std::vector<int> heights;
for (auto rect : targetRects_) { // copy
// To fill gaps
rect.width += 1;
rect.height += 1;
// Check ROI
if ( !(rect.x >= 0 && rect.width >= 0 && rect.x + rect.width <= grayImage.cols &&
rect.y >= 0 && rect.height >= 0 && rect.y + rect.height <= grayImage.rows) ) {
qDebug() << "targetRects contains invalid rect data.";
continue;
}
// Calculate average color
cv::Mat roiImage = grayImage(rect);
if (rect.width > 3 && rect.height > 3) {
rect.x += rect.width / 3;
rect.y += rect.height / 3;
rect.width /= 3;
rect.height /= 3;
}
cv::Mat averageRoiImage = grayImage(rect);
cv::Mat rowAverage, average;
cv::reduce(averageRoiImage, rowAverage, 0, CV_REDUCE_AVG);
cv::reduce(rowAverage, average, 1, CV_REDUCE_AVG);
// Set all pixels in ROI as its average color
auto averageValue = average.at<unsigned char>(0);
roiImage = cv::Scalar(averageValue);
// Set results
auto brickDetected = averageValue > threshold_ ? 1 : 0;
heights.push_back(brickDetected);
}
// check change
addHeightsCache(heights);
checkResult();
{
std::lock_guard<std::mutex> lock(mutex_);
cv::cvtColor(grayImage, image_, CV_GRAY2BGR);
emit imageChanged();
}
emit update();
}
/* virtual */ opera_update_checker::status::Status OAUCRequestImpl::ComposeMainUpdatePart(const UpdateDataProvider& provider, bool with_metrics)
{
try
{
if (!document_.RootElement())
document_.Parse(update_request_root);
if (document_.Error())
return opera_update_checker::status::StatusCode::FAILED;
TiXmlDocument temp;
TIXML_STRING os(provider.GetOsName() ? provider.GetOsName() : "");
TIXML_STRING encoded_os;
TIXML_STRING ver(provider.GetOsVersion() ? provider.GetOsVersion() : "");
TIXML_STRING encoded_ver;
TIXML_STRING arch(provider.GetArch() ? provider.GetArch() : "");
TIXML_STRING encoded_arch;
TIXML_STRING package(provider.GetPackage() ? provider.GetPackage() : "");
TIXML_STRING encoded_package;
const char* cuuid;
opera_update_checker::status::Status status = provider.GetUUID(cuuid);
if (status != opera_update_checker::status::StatusCode::OK)
return status;
TIXML_STRING uuid(cuuid ? cuuid : "");
TIXML_STRING encoded_uuid;
const char* clut;
status = provider.GetLUT(clut);
if (status != opera_update_checker::status::StatusCode::OK)
return status;
TIXML_STRING lut(clut ? clut : "");
TIXML_STRING encoded_lut;
TIXML_STRING firstrunversion(provider.GetFirstRunVersion() ? provider.GetFirstRunVersion() : "");
TIXML_STRING encoded_firstrunversion;
TIXML_STRING firstrunts(provider.GetFirstRunTimestamp() ? provider.GetFirstRunTimestamp() : "");
TIXML_STRING encoded_firstrunts;
TIXML_STRING user_loc(provider.GetUserLocation() ? provider.GetUserLocation() : "");
TIXML_STRING encoded_user_loc;
TIXML_STRING detected_loc(provider.GetDetectedLocation() ? provider.GetDetectedLocation() : "");
TIXML_STRING encoded_detected_loc;
TIXML_STRING active_loc(provider.GetActiveLocation() ? provider.GetActiveLocation() : "");
TIXML_STRING encoded_active_loc;
TIXML_STRING region(provider.GetRegion() ? provider.GetRegion() : "");
TIXML_STRING encoded_region;
document_.EncodeString(os, &encoded_os);
document_.EncodeString(ver, &encoded_ver);
document_.EncodeString(arch, &encoded_arch);
document_.EncodeString(package, &encoded_package);
document_.EncodeString(uuid, &encoded_uuid);
document_.EncodeString(lut, &encoded_lut);
document_.EncodeString(firstrunversion, &encoded_firstrunversion);
document_.EncodeString(firstrunts, &encoded_firstrunts);
document_.EncodeString(user_loc, &encoded_user_loc);
document_.EncodeString(detected_loc, &encoded_detected_loc);
document_.EncodeString(active_loc, &encoded_active_loc);
document_.EncodeString(region, &encoded_region);
sprintf(shared_work_buffer,
update_metrics_part_template,
encoded_os.c_str() ? encoded_os.c_str() : "",
encoded_ver.c_str() ? encoded_ver.c_str() : "",
encoded_arch.c_str() ? encoded_arch.c_str() : "",
encoded_package.c_str() ? encoded_package.c_str() : "",
encoded_uuid.c_str() ? encoded_uuid.c_str() : "",
encoded_lut.c_str() ? encoded_lut.c_str() : "",
encoded_firstrunversion.c_str() ? encoded_firstrunversion.c_str() : "",
encoded_firstrunts.c_str() ? encoded_firstrunts.c_str() : "",
encoded_user_loc.c_str() ? encoded_user_loc.c_str() : "",
encoded_detected_loc.c_str() ? encoded_detected_loc.c_str() : "",
encoded_active_loc.c_str() ? encoded_active_loc.c_str() : "",
encoded_region.c_str() ? encoded_region.c_str() : "");
temp.Parse(shared_work_buffer);
if (temp.Error())
return opera_update_checker::status::StatusCode::FAILED;
OAUC_ASSERT(document_.RootElement() && document_.RootElement()->FirstChildElement());
TiXmlElement* child = document_.RootElement()->FirstChildElement();
while (opera_update_checker::system_utils::SystemUtils::strnicmp(child->Value(), "system", 6) != 0)
{
child = child->NextSiblingElement();
OAUC_ASSERT(child);
}
TiXmlElement* elm = temp.RootElement();
do
{
if (with_metrics || opera_update_checker::system_utils::SystemUtils::strnicmp(elm->Value(), "metrics", 7) != 0)
child->InsertEndChild(*elm);
elm = elm->NextSiblingElement();
}
while (elm);
}
catch (...)
{
return opera_update_checker::status::StatusCode::OOM;
}
return opera_update_checker::status::StatusCode::OK;
}
myvector<int> create_srandom(const int tau, int& spread, libbase::int32u& seed,
const int max_attempts)
{
// set up time-keepers
libbase::pacifier p;
// set up random-number generation
libbase::truerand trng;
libbase::randgen seeder;
seeder.seed(trng.ival());
libbase::randgen prng;
// initialize space for results
myvector<int> lut(tau);
bool failed = true;
while (failed)
{
std::cerr << "Searching for solution at spread " << spread << std::endl;
// loop for a number of attempts at the given Spread, then
// reduce and continue as necessary
libbase::cputimer tmain("Attempt timer");
int attempt;
for (attempt = 0; attempt < max_attempts && failed; attempt++)
{
std::cerr << p.update(attempt, max_attempts);
// re-seed random generator
seed = seeder.ival();
prng.seed(seed);
// set up working variables
mylist<int> unused(tau);
unused.sequence();
// loop to fill all entries in the interleaver - or until we fail
failed = false;
for (int i = 0; i < tau && !failed; i++)
{
// set up for the current entry
mylist<pair<int> > untried = unused.pairup();
// loop for the current entry
// until we find a suitable value or totally fail trying
while (!failed)
{
// choose a random number from what's left to try
mylist<pair<int> >::iterator ndx = untried.getiteratorat(
prng.ival(untried.size()));
const int n = ndx->value;
// if it's no good remove it from the list of options
if (!satisfiesspread(lut, n, i, spread))
{
untried.erase(ndx);
failed = untried.empty();
continue;
}
// if it's a suitable value, insert & mark as used
else
{
unused.erase(ndx->index);
lut(i) = n;
break;
}
}
}
}
// show user how fast we're working
tmain.stop();
std::cerr << "Attempts: " << attempt << " in " << tmain << std::endl;
std::cerr << "Speed: " << double(attempt) / tmain.elapsed()
<< " attempts/sec" << std::endl;
// if this failed, prepare for the next attempt
if (failed)
spread--;
}
// stop timers
std::cerr << p.update(max_attempts, max_attempts);
return lut;
}
vector<tBGRA> getLinearLut() {
vector<tBGRA> lut( 256 );
boost::iota( lut, incrementBGRA() );
return lut;
}
std::vector< uint8_t > deserializeLookupTable1D( const Event& event )
{
auto data = GetLookupTable1D( event.getData( ));
LBASSERT( data->lut()->Length() == 1024 );
return deserializeVector( data->lut( ));
}
float aux_func(float a, float b) {
return Sign(a)*Sign(b)*std::min(abs(a), abs(b)) + lut(a, b);
}
int ImageProcCV::imageNormalize(cv::Mat &_input, cv::Mat &_output, int method)
{
//this function only accepts CV_8U data type
int retVal = NO_ERRORS;
cv::Mat& input = _input;
cv::Mat& output = _output;
//check input
if (!input.data)
{
retVal = EMPTY_IMAGE_MTRX;
return retVal;
}
else if (input.type() != CV_8UC1)
{
retVal = INV_IMG_TYPE;
return retVal;
}
output = cv::Mat::zeros(input.size(),CV_64F);
int rows = input.rows;
int cols = input.cols;
if(input.isContinuous() && output.isContinuous())
{
cols *= rows;
rows = 1;
}
switch (method)
{
case NORM_GLOBAL:
for(int i = 0; i < rows; i++)
{
uchar *_input = input.ptr<uchar>(i);
double *_output = output.ptr<double>(i);
for(int j = 0; j < cols; j++)
{
//double val = (double)_input[j]/255.0f;
_output[j] = (double)_input[j]/255.0f;
}
}
break;
case NORM_STD:
int max = 0, min = 255;
//finding maximu and minimum elements in the matrix
max = *std::max_element(input.begin<uchar>(), input.end<uchar>());
min = *std::min_element(input.begin<uchar>(), input.end<uchar>());
/*for(cv::MatIterator_<uchar> it = input.begin<uchar>(); it != input.end<uchar>(); it++)
{
if(*it >= max)
{
max = *it;
}
if(*it <= min)
{
min = *it;
}
}*/
if(min == max)
{
retVal = EQUAL_INTENSITY_PIXELS;
}
else
{
retVal = NO_ERRORS;
}
cv::Mat lut(1, 256, CV_8U);
uchar* p = lut.data;
for( int i = 0; i < 256; ++i)
p[i] = (i - min) /(double)((min == max)? 1:(max -min));
cv::LUT(input,lut,output);
break;
}
return retVal;
}
void log_to_linear_node_t::do_process( const image::const_image_view_t& src, const image::image_view_t& dst, const render::render_context_t& context)
{
if( get_value<int>( param( "convert")))
{
switch( get_value<int>( param( "method")))
{
case cineon_conv:
{
IECore::LinearToCineonDataConversion<float,boost::uint16_t> conv( get_value<float>( param( "cin_gamma")),
get_value<float>( param( "cin_white")),
get_value<float>( param( "cin_black")));
boost::scoped_array<boost::uint16_t> lut( new boost::uint16_t[1<<16]);
init_lut( lut.get(), conv);
//cineon_linear_to_log_fun f( conv);
cineon_linear_to_log_lut_fun f( lut.get());
boost::gil::tbb_transform_pixels( src, dst, f);
}
break;
case redlog_conv:
{
IECore::LinearToCineonDataConversion<float,boost::uint16_t> conv( 1.02f, 1023, 0);
boost::scoped_array<boost::uint16_t> lut( new boost::uint16_t[1<<16]);
init_lut( lut.get(), conv);
//cineon_linear_to_log_fun f( conv);
cineon_linear_to_log_lut_fun f( lut.get());
boost::gil::tbb_transform_pixels( src, dst, f);
}
break;
case exrdpx_conv:
{
exrdpx_linear_to_log_fun f;
boost::gil::tbb_transform_pixels( src, dst, f);
}
break;
}
}
else
{
switch( get_value<int>( param( "method")))
{
case cineon_conv:
{
IECore::CineonToLinearDataConversion<boost::uint16_t, float> conv( get_value<float>( param( "cin_gamma")),
get_value<float>( param( "cin_white")),
get_value<float>( param( "cin_black")));
cineon_log_to_linear_fun f( conv);
boost::gil::tbb_transform_pixels( src, dst, f);
}
break;
case redlog_conv:
{
IECore::CineonToLinearDataConversion<boost::uint16_t, float> conv( 1.02f, 1023, 0);
cineon_log_to_linear_fun f( conv);
boost::gil::tbb_transform_pixels( src, dst, f);
}
break;
case exrdpx_conv:
{
exrdpx_log_to_linear_fun f;
boost::gil::tbb_transform_pixels( src, dst, f);
}
break;
}
}
}
bool task3_5(const cv::Mat& image, const cv::Mat& orig) {
cv::Mat grey, tmp, res;
image.copyTo(grey);
grey.convertTo(grey, CV_32F);
grey.copyTo(res);
res.convertTo(res, CV_8U);
std::vector<cv::Mat> planes(2, cv::Mat());
std::vector<cv::Mat> polar(2, cv::Mat());
cv::dft(grey, tmp, cv::DFT_COMPLEX_OUTPUT);
cv::split(tmp, planes);
cv::cartToPolar(planes[0], planes[1], polar[0], polar[1]);
int cx = polar[0].cols / 2;
int cy = polar[0].rows / 2;
cv::Point max;
cv::Mat top = polar[0].rowRange(0, cx);
cv::Mat bot = polar[0].rowRange(cx, polar[0].rows);
int row = 0;
do {
cv::minMaxLoc(top.rowRange(row++, top.rows), 0, 0, 0, &max);
} while (max.x == 0);
int r = 3;
cv::Mat noizeCol = polar[0].colRange(max.x - r, max.x + r);
cv::Mat noizeRow = polar[0].rowRange(max.y - r, max.y + r);
cv::Mat blurCol = polar[0].colRange(max.x - 12, max.x - 12 + 2 * r);
cv::Mat blurRow = polar[0].rowRange(max.y - 3 * r, max.y - r);
blurCol.copyTo(noizeCol);
blurRow.copyTo(noizeRow);
cv::Mat noizeColB = polar[0].colRange(polar[0].cols - max.x - r, polar[0].cols - max.x + r);
cv::Mat noizeRowB = polar[0].rowRange(polar[0].rows - max.y - r, polar[0].rows - max.y + r);
blurCol.copyTo(noizeColB);
blurRow.copyTo(noizeRowB);
cv::Mat roi = polar[0];
cv::Mat mean, stddev, tmp1;
roi = roi.colRange(max.x + 20, roi.cols - max.x - 20).rowRange(max.y + 20, roi.cols - max.y - 20);
for (int i = 0; i < roi.rows; ++i) {
cv::Mat row = roi.row(i);
cv::meanStdDev(row, mean, stddev);
float m = mean.at<double>(0, 0);
float st = stddev.at<double>(0, 0);
for (Mfit mfit = row.begin<float>(); mfit != row.end<float>(); ++mfit) {
if (*mfit > m + 1.5 * st) {
*mfit = 0.5 * m;
}
}
}
visualization(polar[0], tmp);
//
//
// cv::namedWindow("Lesson 2", CV_WINDOW_NORMAL);
// cv::imshow("Lesson 2", tmp);
// cv::waitKey(0);
cv::polarToCart(polar[0], polar[1], planes[0], planes[1]);
cv::merge(planes, tmp);
cv::dft(tmp, tmp, cv::DFT_SCALE | cv::DFT_INVERSE | cv::DFT_REAL_OUTPUT);
tmp.convertTo(tmp, CV_8U);
cv::Mat lut(1, 256, CV_32F, cv::Scalar(0));
for (int i = 0; i < 256; ++i) {
lut.at<float>(0, i) = i;
}
for (int i = 65; i < 200; ++i) {
lut.at<float>(0, i) = i - 30;
}
for (int i = 200; i < 220; ++i) {
lut.at<float>(0, i) = i - 20;
}
lut.convertTo(lut, CV_8U);
tmp.convertTo(tmp, CV_8U);
cv::normalize(tmp, tmp, 0, 255, cv::NORM_MINMAX);
cv::LUT(tmp, lut, tmp);
cv::GaussianBlur(tmp, tmp, cv::Size(3, 3), 1);
cv::medianBlur(tmp, tmp, 3);
cv::Mat result;
cv::matchTemplate(orig, tmp, result, CV_TM_SQDIFF);
std::cout << "RMSE Task 3.5: " << result / (orig.cols * orig.rows) << std::endl;
concatImages(res, tmp, res);
cv::absdiff(tmp, orig, tmp);
concatImages(res, tmp, res);
cv::absdiff(image, orig, tmp);
concatImages(res, tmp, res);
concatImages(res, orig, res);
// cv::namedWindow("Lesson 2", CV_WINDOW_NORMAL);
// cv::imshow("Lesson 2", res);
// cv::waitKey(0);
return cv::imwrite(PATH + "Task3_5.jpg", res);
}
void threshold(const cv::Mat& src, uchar t, cv::Mat& dst) {
cv::Mat lut(1, 256, CV_8U, cv::Scalar(0));
lut.colRange(t + 1, lut.cols) = cv::Scalar(255);
cv::LUT(src, lut, dst);
}
