void SurfaceMesh<triangle>::add_face(int p1, int p2, int p3, int p4, int sig, const dim3 &dir) {
point proj[4];
proj[0] = pts[p1];
proj[1] = pts[p2];
proj[2] = pts[p3];
proj[3] = pts[p4];
for (int i = 0; i < 4; i++) {
proj[i].x *= (1 - dir.i);
proj[i].y *= (1 - dir.j);
proj[i].z *= (1 - dir.k);
}
double q11 = quality(proj[0], proj[1], proj[2]);
double q12 = quality(proj[0], proj[2], proj[3]);
double q21 = quality(proj[0], proj[1], proj[3]);
double q22 = quality(proj[1], proj[2], proj[3]);
if (std::min(q11, q12) > std::min(q21, q22)) {
elems.push_back(triangle{p1, p2, p3});
elems.push_back(triangle{p1, p3, p4});
} else {
elems.push_back(triangle{p1, p2, p4});
elems.push_back(triangle{p2, p3, p4});
}
facetype.push_back(sig);
facetype.push_back(sig);
}
struct fraction_precision closest_fraction(double r, int steps,
int (*callback) (struct
fraction_precision))
{
const double x = r > 0 ? r : -r;
struct fraction_precision loop = { x, 1, 0 }, best = loop, optimum = loop;
while (steps--) {
double y = fraction(loop);
loop.precision = x == y ? 9999 : -log10((y > x ? y / x : x / y) - 1);
if (loop.precision > best.precision) {
if (callback != NULL && quality(loop) > quality(optimum)) {
steps = (*callback) (optimum = loop);
}
best = loop;
}
#if NAIVE_SLOW_ALGORITHM /* Easy to understand */
(y < x) ? ++loop.n : ++loop.d;
#else /* harder but MUCH faster */
(x > 1) ? (loop.n = x * ++loop.d + 0.5) : (loop.d = ++loop.n / x + 0.5);
#endif
}
return best;
}
void pyglpk_kkt_check(glp_prob *lp, int scaling, pyglpk_kkt_t *kkt)
{
#if GLPK_VERSION(4, 49)
int m = glp_get_num_rows(lp);
/* check primal equality constraints */
glp_check_kkt(lp, GLP_SOL, GLP_KKT_PE,
&(kkt->pe_ae_max), &(kkt->pe_ae_row),
&(kkt->pe_re_max), &(kkt->pe_re_row));
kkt->pe_quality = quality(kkt->pe_re_max);
/* check primal bound constraints */
glp_check_kkt(lp, GLP_SOL, GLP_KKT_PB,
&(kkt->pb_ae_max), &(kkt->pb_ae_ind),
&(kkt->pb_re_max), &(kkt->pb_re_ind));
kkt->pb_quality = quality(kkt->pb_re_max);
/* check dual equality constraints */
glp_check_kkt(lp, GLP_SOL, GLP_KKT_DE,
&(kkt->de_ae_max), &(kkt->de_ae_col),
&(kkt->de_re_max), &(kkt->de_re_col));
kkt->de_ae_col = kkt->de_ae_col == 0 ? 0 : kkt->de_ae_col - m;
kkt->de_re_col = kkt->de_re_col == 0 ? 0 : kkt->de_re_col - m;
kkt->de_quality = quality(kkt->de_re_max);
/* check dual bound constraints */
glp_check_kkt(lp, GLP_SOL, GLP_KKT_DB,
&(kkt->db_ae_max), &(kkt->db_ae_ind),
&(kkt->db_re_max), &(kkt->db_re_ind));
kkt->db_quality = quality(kkt->db_re_max);
#else
lpx_check_kkt(lp, scaling, kkt);
#endif
}
void Image::paint(GfxPainter &p)
{
if(!_collection->isOnScreen(_idx))
return;
if(!_loaded) {
loadImage(_str, QList<QSize>() << QSize(320, 240));
_loaded = true;
}
if(_def.value() == 2. && !_maximized.isNull()) {
clear();
addImage(_maximized);
addImage(_small);
addImage(_zoomed);
addImage(_timeView);
_maximized = _small = _zoomed = _timeView = QImage();
}
_color.rotate().setValue(rotate().value());
_color.quality().setValue(quality().value());
GfxCanvasMipImage::paint(p);
}
void GfxCanvasText::paint(GfxPainter &p)
{
if(_img.isNull())
return;
qreal op = p.opacity();
p.setOpacity(op * layerVisible());
QSize _s = _img.size();
QPoint point = getImgPoint();
if(1. != layerScale()) {
QMatrix m;
m.translate(layerX(), layerY());
m.scale(layerScale(), layerScale());
m.translate(-_size.width() / 2, -_size.height() / 2);
m.translate(point.x(), point.y());
p.drawImageTransformed(m, _img, quality().value() != 0.);
} else {
p.drawImage(int(layerX()) + point.x() - _size.width() / 2,
int(layerY()) + point.y() - _size.height() / 2, _img);
if(gfx_show_image_bounds) {
QRect r(int(layerX()) + point.x() - _size.width() / 2,
int(layerY()) + point.y() - _size.height() / 2,
_img.width(),
_img.height());
p.fillRect(r, QColor(0, 0, 255, 127));
}
}
p.setOpacity(op);
GfxCanvasItem::paint(p);
}
void GfxCanvasImage::paint(GfxPainter &p)
{
if(_img.isNull())
return;
qreal op = p.opacity();
p.setOpacity(op * layerVisible());
if(_rotate.value() || 1. != layerScale()) {
QMatrix m;
m.translate(layerX(), layerY());
m.rotate(_rotate.value());
m.scale(layerScale(), layerScale());
m.translate(-_s.width() / 2, -_s.height() / 2);
p.drawImageTransformed(m, _img, quality().value() != 0.);
} else {
if(subPixelPlacement()) {
p.drawImage(qreal(layerX() - qreal(_s.width()) / 2.),
int(layerY() - qreal(_s.height()) / 2.), _img);
} else {
p.drawImage(int(layerX() - qreal(_s.width()) / 2.),
int(layerY() - qreal(_s.height()) / 2.), _img);
}
if(gfx_show_image_bounds) {
QRect r(int(layerX() - qreal(_s.width()) / 2.),
int(layerY() - qreal(_s.height()) / 2.),
_s.width(), _s.height());
p.fillRect(r, QColor(0, 0, 255, 127));
}
}
p.setOpacity(op);
GfxCanvasItem::paint(p);
}
bool writeResource(const String& path, ResourceDatabase* resource) const
{
bool ok = true;
for(unsigned i=0; i<resource->count<Image>(); ++i)
ok &= saveJPG(resource->get<Image>(i), path, quality());
return ok;
}
bool writeResource(VirtualFile* file, ResourceDatabase* resource) const
{
bool ok = true;
for(unsigned i=0; i<resource->count<Image>(); ++i)
ok &= saveJPG(resource->get<Image>(i), file, quality());
return ok;
}
int DIA_getLameSettings(ADM_audioEncoderDescriptor *descriptor)
{
int ret=0;
char string[400];
uint32_t mmode,ppreset;
#define SZT(x) sizeof(x)/sizeof(diaMenuEntry )
#define PX(x) &(lameParam->x)
LAME_encoderParam *lameParam;
ADM_assert(sizeof(LAME_encoderParam)==descriptor->paramSize);
lameParam=(LAME_encoderParam*)descriptor->param;
mmode=lameParam->mode;
ppreset=lameParam->preset;
diaMenuEntry channelMode[]={
{ADM_STEREO, QT_TR_NOOP("Stereo"),NULL},
{ADM_JSTEREO, QT_TR_NOOP("Joint stereo"),NULL},
{ADM_MONO, QT_TR_NOOP("Mono"),NULL}};
diaElemMenu menuMode(&mmode, QT_TR_NOOP("C_hannel mode:"), SZT(channelMode),channelMode);
diaMenuEntry encodingMode[]={
{ADM_LAME_PRESET_CBR, QT_TR_NOOP("CBR"),NULL},
{ADM_LAME_PRESET_ABR, QT_TR_NOOP("ABR"),NULL},
#if 0
{ADM_LAME_PRESET_EXTREME, QT_TR_NOOP("Extreme"),NULL}
#endif
};
diaElemMenu Mode(&ppreset, QT_TR_NOOP("Bit_rate mode:"), SZT(encodingMode),encodingMode);
#define BITRATE(x) {x,QT_TR_NOOP(#x)}
diaMenuEntry bitrateM[]={
BITRATE(56),
BITRATE(64),
BITRATE(80),
BITRATE(96),
BITRATE(112),
BITRATE(128),
BITRATE(160),
BITRATE(192),
BITRATE(224)
};
diaElemMenu bitrate(&(descriptor->bitrate), QT_TR_NOOP("_Bitrate:"), SZT(bitrateM),bitrateM);
diaElemUInteger quality(PX(quality),QT_TR_NOOP("_Quality:"),0,9);
diaElemToggle reservoir(PX(disableReservoir),QT_TR_NOOP("_Disable reservoir:"));
diaElem *elems[]={&menuMode,&Mode,&quality,&bitrate,&reservoir};
if( diaFactoryRun(QT_TR_NOOP("LAME Configuration"),5,elems))
{
lameParam->mode=(ADM_mode)mmode;
lameParam->preset=(ADM_LAME_PRESET)ppreset;
return 1;
}
return 0;
}
bool configure (CONFcouple **setup)
{
int ret = 0;
char string[400];
uint32_t mmode, ppreset;
#define SZT(x) sizeof(x)/sizeof(diaMenuEntry )
#define PX(x) &(config.x)
lame_encoder config=defaultConfig;
if(*setup)
{
ADM_paramLoad(*setup,lame_encoder_param,&config);
}
ppreset = config.preset;
diaMenuEntry encodingMode[] = {
{ADM_LAME_PRESET_CBR, QT_TRANSLATE_NOOP("lame","CBR"), NULL},
{ADM_LAME_PRESET_ABR, QT_TRANSLATE_NOOP("lame","ABR"), NULL},
};
diaElemMenu Mode (&ppreset, QT_TRANSLATE_NOOP("lame","Bit_rate mode:"), SZT (encodingMode), encodingMode);
#define BITRATE(x) {x,QT_TRANSLATE_NOOP("lame",#x)}
diaMenuEntry bitrateM[] = {
BITRATE (56),//56
BITRATE (64),
BITRATE (80),
BITRATE (96),
BITRATE (112),
BITRATE (128),
BITRATE (160),
BITRATE (192),
BITRATE (224),
BITRATE (256),
BITRATE (320)
};
//***
diaElemMenu bitrate (&(config.bitrate), QT_TRANSLATE_NOOP("lame","_Bitrate:"), SZT (bitrateM),
bitrateM);
diaElemUInteger quality (PX (quality), QT_TRANSLATE_NOOP("lame","_Quality:"), 0, 9);
bool reservoir32=config.disableBitReservoir;
diaElemToggle reservoir (&reservoir32,
QT_TRANSLATE_NOOP("lame","_Disable reservoir:"));
diaElem *elems[] = { &Mode, &bitrate,&quality, &reservoir };
if (diaFactoryRun (QT_TRANSLATE_NOOP("lame","LAME Configuration"), 4, elems))
{
config.preset=(ADM_LAME_PRESET)ppreset;
config.disableBitReservoir=reservoir32;
if(*setup) delete *setup;
*setup=NULL;
ADM_paramSave(setup,lame_encoder_param,&config);
defaultConfig=config;
return 1;
}
return 0;
}
bool VideoOutput::onSetQuality(Quality q)
{
DPTR_D(VideoOutput);
Quality _q = quality();
d.impl->onSetQuality(q);
d.quality = d.impl->quality();
return _q != q;
}
void pyglpk_int_check(glp_prob *lp, pyglpk_kkt_t *kkt)
{
#if GLPK_VERSION(4, 49)
/* check primal equality constraints */
glp_check_kkt(lp, GLP_MIP, GLP_KKT_PE,
&(kkt->pe_ae_max), &(kkt->pe_ae_row),
&(kkt->pe_re_max), &(kkt->pe_re_row));
kkt->pe_quality = quality(kkt->pe_re_max);
/* check primal bound constraints */
glp_check_kkt(lp, GLP_MIP, GLP_KKT_PB,
&(kkt->pb_ae_max), &(kkt->pb_ae_ind),
&(kkt->pb_re_max), &(kkt->pb_re_ind));
kkt->pb_quality = quality(kkt->pb_re_max);
#else
lpx_check_int(lp, kkt);
#endif
}
static void report_before(MagickWand *mw, size_t size_in)
{
const double ks = size_in / 1024.;
fprintf(stdout,
"Before quality:%lu colors:%lu size:%5.1fkB type:%s format:%s ",
quality(mw),
(unsigned long)unique_colors(mw),
ks, type2str(MagickGetImageType(mw)),
MagickGetImageFormat(mw));
}
bool configure(CONFcouple **setup)
{
uint32_t mmode,ppreset;
ELEM_TYPE_FLOAT qqual;
vorbis_encoder config=defaultConfig;
if(*setup)
{
ADM_paramLoad(*setup,vorbis_encoder_param,&config);
}
mmode=config.mode;
qqual=(ELEM_TYPE_FLOAT)config.quality;
diaMenuEntry channelMode[]={
{ADM_VORBIS_VBR, QT_TRANSLATE_NOOP("vorbis","VBR"),NULL},
{ADM_VORBIS_QUALITY, QT_TRANSLATE_NOOP("vorbis","Quality based"),NULL}};
diaElemMenu menuMode(&mmode, QT_TRANSLATE_NOOP("vorbis","_Mode:"), SZT(channelMode),channelMode);
diaMenuEntry bitrateM[]={
BITRATE(56),
BITRATE(64),
BITRATE(80),
BITRATE(96),
BITRATE(112),
BITRATE(128),
BITRATE(160),
BITRATE(192),
BITRATE(224)
};
diaElemMenu bitrate(&(config.bitrate), QT_TRANSLATE_NOOP("vorbis","_Bitrate:"), SZT(bitrateM),bitrateM);
diaElemFloat quality(&qqual,QT_TRANSLATE_NOOP("vorbis","_Quality:"),-1.,10.);
diaElem *elems[]={&menuMode,&bitrate,&quality};
if( diaFactoryRun(QT_TRANSLATE_NOOP("vorbis","Vorbis Configuration"),3,elems))
{
config.mode=(ADM_VORBIS_MODE)mmode;
config.quality=(float)qqual;
if(*setup) delete *setup;
*setup=NULL;
ADM_paramSave(setup,vorbis_encoder_param,&config);
defaultConfig=config;
return 1;
}
return 0;
}
int DIA_getVorbisSettings(ADM_audioEncoderDescriptor *descriptor)
{
int ret=0;
char string[400];
uint32_t mmode,ppreset;
ELEM_TYPE_FLOAT qqual;
#define SZT(x) sizeof(x)/sizeof(diaMenuEntry )
#define PX(x) &(lameParam->x)
VORBIS_encoderParam *vorbisParam;
ADM_assert(sizeof(VORBIS_encoderParam)==descriptor->paramSize);
vorbisParam=(VORBIS_encoderParam*)descriptor->param;
mmode=vorbisParam->mode;
qqual=(ELEM_TYPE_FLOAT)vorbisParam->quality;
diaMenuEntry channelMode[]={
{ADM_VORBIS_VBR, QT_TR_NOOP("VBR"),NULL},
{ADM_VORBIS_QUALITY, QT_TR_NOOP("Quality based"),NULL}};
diaElemMenu menuMode(&mmode, QT_TR_NOOP("_Mode:"), SZT(channelMode),channelMode);
#define BITRATE(x) {x,QT_TR_NOOP(#x)}
diaMenuEntry bitrateM[]={
BITRATE(56),
BITRATE(64),
BITRATE(80),
BITRATE(96),
BITRATE(112),
BITRATE(128),
BITRATE(160),
BITRATE(192),
BITRATE(224)
};
diaElemMenu bitrate(&(descriptor->bitrate), QT_TR_NOOP("_Bitrate:"), SZT(bitrateM),bitrateM);
diaElemFloat quality(&qqual,QT_TR_NOOP("_Quality:"),-1.,10.);
diaElem *elems[]={&menuMode,&bitrate,&quality};
if( diaFactoryRun(QT_TR_NOOP("Vorbis Configuration"),3,elems))
{
vorbisParam->mode=(ADM_VORBIS_MODE)mmode;
vorbisParam->quality=(float)qqual;
return 1;
}
return 0;
}
QVariant S60AudioEncoderControl::encodingOption(const QString &codec, const QString &name) const
{
if (codec == "PCM") {
QAudioFormat fmt = m_session->format();
if(qstrcmp(name.toLocal8Bit().constData(), "quality") == 0)
return QVariant(quality());
else if(qstrcmp(name.toLocal8Bit().constData(), "channels") == 0)
return QVariant(fmt.channels());
else if(qstrcmp(name.toLocal8Bit().constData(), "samplerate") == 0)
return QVariant(fmt.frequency());
}
return QVariant();
}
static void report_after(MagickWand *mw, size_t size_in, size_t size_out)
{
const double ks = size_in / 1024.;
const double kd = size_out / 1024.;
const double ksave = ks - kd;
const double kpct = ksave * 100. / ks;
fprintf(stdout,
"After quality:%lu colors:%lu size:%5.1fkB saved:%5.1fkB (%.1f%%)\n",
(unsigned long)quality(mw),
(unsigned long)unique_colors(mw),
kd, ksave, kpct);
}
void OpticalFlow::update_state(const OpticalFlow_state &state)
{
_state = state;
_last_update_ms = AP_HAL::millis();
// write to log and send to EKF if new data has arrived
AP::ahrs_navekf().writeOptFlowMeas(quality(),
_state.flowRate,
_state.bodyRate,
_last_update_ms,
get_pos_offset());
Log_Write_Optflow();
}
void Particle::update()
{//update the velocity, position, and performance
std::uniform_real_distribution<double> dist(0,1);
//modify velocity
xvel *= inertia;
xvel += cognit * dist(rng) * (xbest - xpos);
xvel += social * dist(rng) * (xglobal - xpos);
yvel *= inertia;
yvel += cognit * dist(rng) * (ybest - ypos);
yvel += social * dist(rng) * (yglobal - ypos);
if (std::fabs(xvel) > std::pow(maxvel, 2.0f))
xvel *= maxvel / std::sqrt(std::pow(xvel, 2.0f) + std::pow(yvel, 2.0f));
if (std::fabs(yvel) > std::pow(maxvel, 2.0f))
yvel *= maxvel / std::sqrt(std::pow(xvel, 2.0f) + std::pow(yvel, 2.0f));
//modify position
xpos += xvel;
ypos += yvel;
//update personal best
if (quality(xpos, ypos) > quality(xbest, ybest))
{
xbest = xpos;
ybest = ypos;
}
//update global best
if (quality(xpos, ypos) > quality(xglobal, yglobal))
{
xglobal = xpos;
yglobal = ypos;
}
}
int LTKInkFileReader::readUnipenInkFile(const string& inkFile, LTKTraceGroup& traceGroup, LTKCaptureDevice& captureDevice, LTKScreenContext& screenContext)
{
LOG( LTKLogger::LTK_LOGLEVEL_DEBUG) <<
" Entering: LTKInkFileReader::readUnipenInkFile()" << endl;
map<string,string> traceIndicesCommentsMap;
string hierarchyLevel;
string quality("ALL");
LOG( LTKLogger::LTK_LOGLEVEL_DEBUG) <<
" Exiting: LTKInkFileReader::readUnipenInkFile()" << endl;
return (readUnipenInkFileWithAnnotation(inkFile,hierarchyLevel,quality,traceGroup,traceIndicesCommentsMap,captureDevice,screenContext));
}
uint8_t configure(void)
{
uint32_t mmode,ppreset;
ELEM_TYPE_FLOAT qqual;
VORBIS_encoderParam *vParam=&vorbisParam;
mmode=vParam->mode;
qqual=(ELEM_TYPE_FLOAT)vParam->quality;
diaMenuEntry channelMode[]={
{ADM_VORBIS_VBR, QT_TR_NOOP("VBR"),NULL},
{ADM_VORBIS_QUALITY, QT_TR_NOOP("Quality based"),NULL}};
diaElemMenu menuMode(&mmode, QT_TR_NOOP("_Mode:"), SZT(channelMode),channelMode);
diaMenuEntry bitrateM[]={
BITRATE(56),
BITRATE(64),
BITRATE(80),
BITRATE(96),
BITRATE(112),
BITRATE(128),
BITRATE(160),
BITRATE(192),
BITRATE(224)
};
diaElemMenu bitrate(&(vParam->bitrate), QT_TR_NOOP("_Bitrate:"), SZT(bitrateM),bitrateM);
diaElemFloat quality(&qqual,QT_TR_NOOP("_Quality:"),-1.,10.);
diaElem *elems[]={&menuMode,&bitrate,&quality};
if( diaFactoryRun(QT_TR_NOOP("Vorbis Configuration"),3,elems))
{
vParam->mode=(ADM_VORBIS_MODE)mmode;
vParam->quality=(float)qqual;
return 1;
}
return 0;
}
RenderDialog::RenderDialog(QWidget* parent,
QString file, QString lastPath, QSize seyz, QStringList list)
: QDialog(parent),
fileName(file), lastDir(lastPath), imgSize(seyz), presets(list),
nopreset(tr("genome quality")),
sizeValidator(QRegExp("\\d+\\s*x\\s*\\d+"), this)
{
setupUi(this);
setModal(true);
QSettings settings;
m_filePathLineEdit->setText(QDir(lastDir).absoluteFilePath(fileName));
m_qualityComboBox->addItem(nopreset);
m_qualityComboBox->addItems(presets);
QString quality(settings.value("renderdialog/last_quality").toString());
m_qualityComboBox->setCurrentIndex(m_qualityComboBox->findText(quality));
int cnt = settings.beginReadArray("renderdialog/sizes");
if (cnt == 0)
{
QStringList dims;
dims << "640x480" << "600x800" << "1024x768" << "1280x960" << "1280x1024";
m_sizeComboBox->addItems(dims);
}
else
{
for (int i = 0; i < cnt; ++i)
{
settings.setArrayIndex(i);
QString dim( settings.value("dim").toString() );
m_sizeComboBox->addItem(dim);
}
settings.endArray();
sizeText = QString("%1x%2").arg(imgSize.width()).arg(imgSize.height());
if (m_sizeComboBox->findText(sizeText) == -1)
{
m_sizeComboBox->insertItem(0, sizeText);
m_sizeComboBox->setCurrentIndex(0);
}
}
connect(m_filePathButton, SIGNAL(pressed()), this, SLOT(filePathButtonSlot()));
connect(m_addSizeButton, SIGNAL(pressed()), this, SLOT(addSizeButtonSlot()));
connect(m_delSizeButton, SIGNAL(pressed()), this, SLOT(delSizeButtonSlot()));
}
void GfxCanvasCacheLayer::paint(GfxPainter &p)
{
zOrderChildren();
if(_children.isEmpty())
return;
if(Add == _optState && !_children.isEmpty() &&
_children.last() == _addItem) {
GfxPainter p(_img);
if(_addItem->visible().value() != 0.)
_addItem->paint(p);
} else if(None != _optState) {
if(_img.format() == QImage::Format_RGB32)
_img.fill(0xFF000000);
else
_img.fill(0x0);
GfxPainter p(_img);
for(int ii = 0; ii < _children.count(); ++ii) {
GfxCanvasItem *c = _children.at(ii);
if(c->visible().value() != 0.)
c->paint(p);
}
}
_optState = None;
_addItem = 0;
qreal op = p.opacity();
p.setOpacity(op * GfxCanvasItem::layerVisible() * visible().value());
qreal s = GfxCanvasItem::layerScale();
if(1. != s) {
QMatrix m;
m.translate(layerX() + _s.width() / 2, layerY() + _s.height() / 2);
m.scale(s, s);
m.translate(-_s.width() / 2, -_s.height() / 2);
p.drawImageTransformed(m, _img, quality().value() != 0.);
} else {
p.drawImage(int(GfxCanvasItem::layerX()),
int(GfxCanvasItem::layerY()),
_img);
}
p.setOpacity(op);
}
int main(int argc, char **argv){
DynamicArray <char> name(100), read(100), sign(100), quality(100);
IO::FileReader f(argv[1]);
while (1){
if (IO::readLine(f, name) == EOF) break;
if (IO::readLine(f, read) == EOF) break;
if (IO::readLine(f, sign) == EOF) break;
if (IO::readLine(f, quality) == EOF) break;
trim(name.data());
trim(read.data());
unsigned len = std::min(strlen(quality.data()), strlen(read.data()));
read.data()[len] = 0;
quality.data()[len] = 0;
puts(name.data());
puts(read.data());
puts(quality.data());
}
return 0;
}
int main(int argc, char *argv[]) {
if( argc <= 1 ) {
printf("usage: %s image.jpeg\n", argv[0]);
exit(1);
}
argc--;
while(argc > 0) {
argc--;
argv++;
char *name = argv[0];
printf("looking for f5 in: %s\n", name);
if (jpg_open(name) == -1) {
printf("Couldn't open %s\n", name);
continue;
}
double beta = detect_f5(name);
char tmp[80];
int stars;
char outbuf[1024];
sprintf(outbuf, "%s :", name);
if (beta < 0.25) {
// no f5
} else {
//f5 detected
stars = 1;
if (beta > 0.25)
stars++;
if (beta > 0.4)
stars++;
snprintf(tmp, sizeof(tmp), "\n\tCODE RED CODE RED: f5[%f] DETECTED", beta);
strlcat(outbuf, quality(tmp, stars), sizeof(outbuf));
printf("%s\n", outbuf);
}
}
}
void GfxCanvasColor::paint(GfxPainter &p)
{
qreal op = p.opacity();
p.setOpacity(op * layerVisible());
QSize s(int(_s.width() * layerScale()), int(_s.height() * layerScale()));
if(_rotate.value()) {
QMatrix m;
m.translate(layerX(), layerY());
m.rotate(_rotate.value());
m.translate(-s.width() / 2, -s.height() / 2);
p.fillRectTransformed(m, s, color(), quality().value() != 0.);
} else {
p.fillRect(QRect(QPoint(int(layerX() - qreal(s.width()) / 2.),
int(layerY() - qreal(s.height()) / 2.)), s), color());
}
p.setOpacity(op);
GfxCanvasItem::paint(p);
}
int main() {
vector<Node> nodes = { Node(-1, 0), Node(0, 0), Node(0, 1), Node(1, 0), Node(-.5, -.5) };
vector<Curve> curves = { parabolaCurve, semiCircleCurve };
vector<CurvilinearEdge> edges = {
CurvilinearEdge(.5, 1., 0),
CurvilinearEdge(0., .5, 1),
CurvilinearEdge(.5, 1., 1),
CurvilinearEdge(0., .5, 0)
};
vector<Triangle> triangles = {
Triangle(0, 1, 2, 1, -2, 2),
Triangle(1, 3, 2, -5, 0, -1),
Triangle(0, 4, 1, -4, 0, -3)
};
Triangulation K(nodes, triangles, curves, edges);
Triangulation M(K);
vector<double> q;
double mean, minElement;
ofstream quality("Mathematica/quality.dat");
// (1) “good” mesh example
Indicies L = { 0, 1 }; // smart hack — we will not get “bad” triangles now
K.refine(L);
K.save(ofstream("Mathematica/nGoodIni.dat"), ofstream("Mathematica/tGoodIni.dat"));
K.refine(3); // refine 3 times
K.save(ofstream("Mathematica/nGood.dat"), ofstream("Mathematica/tGood.dat"));
// quality measures
q = K.qualityMeasure();
minElement = *min_element(q.begin(), q.end());
mean = accumulate(q.begin(), q.end(), 0.) / q.size();
quality << minElement << '\n' << mean << '\n';
// (2) “bad” example
M.refine();
M.save(ofstream("Mathematica/nBadIni.dat"), ofstream("Mathematica/tBadIni.dat"));
M.refine(3);
M.save(ofstream("Mathematica/nBad.dat"), ofstream("Mathematica/tBad.dat"));
q = M.qualityMeasure();
minElement = *min_element(q.begin(), q.end());
mean = accumulate(q.begin(), q.end(), 0.) / q.size();
quality << minElement << '\n' << mean;
return 0;
}
/**
* Exports classification results
* @param p Prototype structure
* @param fa Feature vector array
* @param as Assignments to protoypes
* @param file File name
*/
void export_class(farray_t *p, farray_t *fa, assign_t *as, const char *file)
{
assert(p && fa && file);
int i, j;
char *l;
FILE *f;
if (verbose > 0)
printf("Exporting classification to '%s'.\n", file);
if (!(f = fopen(file, "w"))) {
error("Could not create file '%s'.", file);
return;
}
/* Print version header */
malheur_version(f);
/* Evaluate some quality functions */
double *e = quality(fa->y, as->label, as->len);
/* Print prototype header */
fprintf(f, "# ---\n# Classification for %s\n", fa->src);
fprintf(f, "# Precision of classification: %4.1f %%\n",
e[Q_PRECISION] * 100.0);
fprintf(f, "# Recall of classification: %4.1f %%\n",
e[Q_RECALL] * 100.0);
fprintf(f, "# F-measure of classification: %4.1f %%\n",
e[Q_FMEASURE] * 100.0);
fprintf(f, "# ---\n# <report> <label> <prototype> <distance>\n");
for (i = 0; i < fa->len; i++) {
j = as->proto[i];
l = as->label[i] ? farray_get_label(p, j) : "rejected";
fprintf(f, "%s %s %s %g\n", fa->x[i]->src, l, p->x[j]->src,
as->dist[i]);
}
fclose(f);
}
/**
* Exports a clustering structure to a text file
* @param c Clustering structure
* @param fa Feature vector array
* @param p Prototype struture
* @param a Assignments of prototypes
* @param file File name
*/
void export_cluster(cluster_t *c, farray_t *p, farray_t *fa, assign_t *a,
const char *file)
{
assert(c && fa && file);
FILE *f;
int i, j;
if (verbose > 0)
printf("Exporting clusters to '%s'.\n", file);
if (!(f = fopen(file, "w"))) {
error("Could not create file '%s'.", file);
return;
}
/* Print version header */
malheur_version(f);
/* Evaluate some quality functions */
double *e = quality(fa->y, c->cluster, c->len);
/* Print prototype header */
fprintf(f, "# ---\n# Clusters for %s\n", fa->src);
fprintf(f, "# Number of cluster: %lu\n", c->num);
fprintf(f, "# Precision of clusters: %4.1f %%\n",
e[Q_PRECISION] * 100.0);
fprintf(f, "# Recall of clusters: %4.1f %%\n", e[Q_RECALL] * 100.0);
fprintf(f, "# F-measure of clusters: %4.1f %%\n", e[Q_FMEASURE] * 100.0);
fprintf(f, "# ---\n# <report> <cluster> <prototype> <distance>\n");
for (i = 0; i < fa->len; i++) {
j = a->proto[i];
fprintf(f, "%s %s %s %g\n", fa->x[i]->src, cluster_get_name(c, i),
p->x[j]->src, a->dist[i]);
}
fclose(f);
}
/**
* Exports a structure of prototypes to a text file
* @param pr Prototype structure
* @param fa Feature vector array
* @param as Assignments to protoypes
* @param file File name
*/
void export_proto(farray_t *pr, farray_t *fa, assign_t *as, const char *file)
{
assert(pr && fa && file);
int i, j;
FILE *f;
if (verbose > 0)
printf("Exporting prototypes to '%s'.\n", file);
if (!(f = fopen(file, "w"))) {
error("Could not create file '%s'.", file);
return;
}
/* Print version header */
malheur_version(f);
/* Evaluate some quality functions */
double *e = quality(fa->y, as->proto, as->len);
/* Print prototype header */
fprintf(f, "# ---\n# Prototypes for %s\n", fa->src);
fprintf(f, "# Number of prototypes: %lu\n", pr->len);
fprintf(f, "# Compression of prototypes: %4.1f %%\n",
pr->len * 100.0 / (double) fa->len);
fprintf(f, "# Precision of prototypes: %4.1f %%\n",
e[Q_PRECISION] * 100.0);
fprintf(f, "# ---\n# <report> <prototype> <distance>\n");
for (i = 0; i < fa->len; i++) {
j = as->proto[i];
fprintf(f, "%s %s %g\n", fa->x[i]->src, pr->x[j]->src, as->dist[i]);
}
fclose(f);
}
