void PPL7FramePainter::paintEvent(QPaintEvent *)
{
if (!img) return;
QPainter painter(this);
QPoint p(0,0);
switch (smode) {
case None:
{
QImage qi((uchar*)img->adr(),img->width(),img->height(), img->pitch(), QImage::Format_RGB32);
painter.drawImage(p,qi);
break;
}
case Fast:
{
int nw,nh;
float ratio=(float)img->width()/(float)img->height();
if (height()*ratio>width()) {
nw=width();
nh=(int)((float)nw/ratio);
} else {
nh=height();
nw=(int)((float)nh*ratio);
}
p.setX((width()-nw)/2);
p.setY((height()-nh)/2);
QImage qi((uchar*)img->adr(),img->width(),img->height(), img->pitch(), QImage::Format_RGB32);
QImage sc=qi.scaled(width(),height(),Qt::KeepAspectRatio,Qt::FastTransformation);
painter.drawImage(p,sc);
break;
}
case Smooth:
{
int nw,nh;
float ratio=(float)img->width()/(float)img->height();
if (height()*ratio>width()) {
nw=width();
nh=(int)((float)nw/ratio);
} else {
nh=height();
nw=(int)((float)nh*ratio);
}
p.setX((width()-nw)/2);
p.setY((height()-nh)/2);
QImage qi((uchar*)img->adr(),img->width(),img->height(), img->pitch(), QImage::Format_RGB32);
QImage sc=qi.scaled(width(),height(),Qt::KeepAspectRatio,Qt::SmoothTransformation);
painter.drawImage(p,sc);
break;
}
}
}
void QuadInterptest::test_flat()
{
dymaxion::QuadInterp qi(4, 2, 2, 2, 2);
ASSERT_TRUE(qi.noCalc);
ASSERT_EQUAL(qi.m_size, 4);
}
int main(int argc, char **argv) {
#ifndef UNITY_BUILD
Q_INIT_RESOURCE(stuff);
Q_INIT_RESOURCE(stuff2);
#endif
QApplication app(argc, argv);
MainWindow *win = new MainWindow();
QImage qi(":/thing.png");
if(qi.width() != 640) {
return 1;
}
QImage qi2(":/thing2.png");
if(qi2.width() != 640) {
return 1;
}
win->setWindowTitle("Meson Qt5 build test");
QLabel *label_stuff = win->findChild<QLabel *>("label_stuff");
if(label_stuff == nullptr) {
return 1;
}
int w = label_stuff->width();
int h = label_stuff->height();
label_stuff->setPixmap(QPixmap::fromImage(qi).scaled(w,h,Qt::KeepAspectRatio));
QLabel *label_stuff2 = win->findChild<QLabel *>("label_stuff2");
if(label_stuff2 == nullptr) {
return 1;
}
w = label_stuff2->width();
h = label_stuff2->height();
label_stuff2->setPixmap(QPixmap::fromImage(qi2).scaled(w,h,Qt::KeepAspectRatio));
win->show();
return app.exec();
return 0;
}
void QuadInterptest::test_calc()
{
dymaxion::QuadInterp qi(4, 2, 4, 6, 8);
ASSERT_TRUE(!qi.noCalc);
ASSERT_EQUAL(qi.calc(2, 2), 5);
}
void RTUVCCamMainWindow::displayImageSlot(QByteArray image,
int width, int height, QString timestamp)
{
QImage qi((const uchar *)image.data(), width, height, QImage::Format_RGB888);
QImage rgbImage = qi.rgbSwapped();
displayPixmap(rgbImage, timestamp);
}
void QuadInterptest::test_QuadInterp()
{
dymaxion::QuadInterp qi(4, 2, 4, 6, 8);
ASSERT_TRUE(!qi.noCalc);
ASSERT_EQUAL(qi.m_size, 4);
}
void can_insert_keyframe_visitor::operator()( const anim::float_curve_t *c)
{
float val = c->evaluate( time_);
val = c->relative_to_absolute( val);
Imath::V2i qi( view_.world_to_screen( Imath::V2f( time_, val)));
can_insert = view_.inside_pick_distance( p_, qi);
}
void QuadInterptest::test_calc_nocalc()
{
dymaxion::QuadInterp qi(4, 2, 2, 2, 2);
ASSERT_TRUE(qi.noCalc);
ASSERT_EQUAL(qi.calc(2, 2), 2);
}
Q_SLOT void sendImage() {
QImage qi(img.image());
qDebug() << "QImage buffer before" << name(qi.constScanLine(0));
emit matSignal(img);
emit imgSignal(img.image());
qDebug() << "QImage buffer after" << name(qi.constScanLine(0));
// Note: this is wrong since img is not allocated on the heap.
//emit imgSignal(QImage(img.mat().data, img.mat().rows, img.mat().cols, QImage::Format_ARGB32, matDeleter, &img));
emit imgSignal(QImage(img.mat().data, img.mat().rows, img.mat().cols, QImage::Format_ARGB32));
}
bool Quotas::save() {
QIntDictIterator<Quota> qi(q);
while (qi.current()) {
if (!qi.current()->save())
return (FALSE);
++qi;
}
return (TRUE);
}
int main()
{
int choice = -1;
Queue q;
while (true)
{
std::cout << "\nMENU\n\n"
<< "Select an action:\n"
<< "1) Add integer to queue\n"
<< "2) Remove integer from queue\n"
<< "3) Print queue contents\n"
<< "4) Run queue debug tests\n"
<< "5) Exit\n\n";
choice = utilities::get_valid_int_in_range(1, 5);
switch (choice)
{
case 1:
{
std::cout << "Add an integer to queue from "
<< "0 through 1000: ";
int val = utilities::get_valid_int_in_range(0, 1000);
q.add_back(val);
break;
}
case 2:
{
int val = q.remove_front();
if (val == -1)
std::cout << "Empty queue!\n";
else
std::cout << "Removed " << val << " from queue.\n";
break;
}
case 3:
{
QueueIter qi(q);
qi.print_elements();
break;
}
case 4:
{
test();
break;
}
case 5:
{
return 0;
}
}
}
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
TEST(UtilsTest, toTextureImage_withSinglePixelImage)
{
QImage qi(1, 1, QImage::Format_ARGB32);
qi.setPixel(0,0, qRgba(1, 2, 3, 4));
cvf::TextureImage i;
cvfqt::Utils::toTextureImage(qi, &i);
ASSERT_EQ(1, i.width());
ASSERT_EQ(1, i.height());
EXPECT_EQ(cvf::Color4ub(1, 2, 3, 4), i.pixel(0,0));
}
void quaterN::hermite0(const quater& a, const quater& b, int duration, const quater& c, const quater& d, float interval)
{
quater qi(1,0,0,0);
hermite(a,b,duration, qi, qi, interval);
quaterN temp;
temp.hermite(qi,qi,duration, c, d, interval);
float totalTime=duration+1;
for(int i=0; i<duration; i++)
{
row(i).slerp(row(i), temp.row(i), (float)(i+1)/totalTime );
}
}
void IMG_linkrelout(Image_t *img, uaddr_t addr, const char *name, const char *segname) {
assert(img != NULL);
sqlq_t qi(img->db, "INSERT OR IGNORE INTO tab_label(name, type, module, segment) VALUES(@N, 0, NULL, "
"(SELECT segid FROM tab_segment WHERE name=@B))");
qi.bind_str(1, name);
qi.bind_str(2, segname);
qi.run();
sqlq_t qu(img->db, "UPDATE tab_reloc SET label=(SELECT labid FROM tab_label WHERE name=@A) "
"WHERE address=@C");
qu.bind_str(1, name);
qu.bind_int(2, addr);
qu.run();
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
TEST(UtilsTest, toTextureImage_premultipliedImageFormat)
{
QImage qi(4, 3, QImage::Format_ARGB32_Premultiplied);
qi.setPixel(0,0, qRgba( 0,10,50,100)); qi.setPixel(1,0, qRgba( 1,11,51,101)); qi.setPixel(2,0, qRgba( 2,12,52,102)); qi.setPixel(3,0, qRgba( 3,13,53,103));
qi.setPixel(0,1, qRgba( 4,14,54,104)); qi.setPixel(1,1, qRgba( 5,15,55,105)); qi.setPixel(2,1, qRgba( 6,16,56,106)); qi.setPixel(3,1, qRgba( 7,17,57,107));
qi.setPixel(0,2, qRgba( 8,18,58,108)); qi.setPixel(1,2, qRgba( 9,19,59,109)); qi.setPixel(2,2, qRgba(10,20,60,110)); qi.setPixel(3,2, qRgba(11,21,61,111));
cvf::TextureImage i;
cvfqt::Utils::toTextureImage(qi, &i);
ASSERT_EQ(4, i.width());
ASSERT_EQ(3, i.height());
EXPECT_EQ(cvf::Color4ub( 0,10,50,100), i.pixel(0,2)); EXPECT_EQ(cvf::Color4ub( 1,11,51,101), i.pixel(1,2)); EXPECT_EQ(cvf::Color4ub( 2,12,52,102), i.pixel(2,2)); EXPECT_EQ(cvf::Color4ub( 3,13,53,103), i.pixel(3,2));
EXPECT_EQ(cvf::Color4ub( 4,14,54,104), i.pixel(0,1)); EXPECT_EQ(cvf::Color4ub( 5,15,55,105), i.pixel(1,1)); EXPECT_EQ(cvf::Color4ub( 6,16,56,106), i.pixel(2,1)); EXPECT_EQ(cvf::Color4ub( 7,17,57,107), i.pixel(3,1));
EXPECT_EQ(cvf::Color4ub( 8,18,58,108), i.pixel(0,0)); EXPECT_EQ(cvf::Color4ub( 9,19,59,109), i.pixel(1,0)); EXPECT_EQ(cvf::Color4ub(10,20,60,110), i.pixel(2,0)); EXPECT_EQ(cvf::Color4ub(11,21,61,111), i.pixel(3,0));
}
void SCRIBUS_API iconToGrayscale(QPixmap* pm)
{
QImage qi(pm->toImage());
int h=qi.height();
int w=qi.width();
QRgb c_rgb;
for (int i=0;i<w;++i)
{
for (int j=0;j<h;++j)
{
c_rgb=qi.pixel(i,j);
int k = qMin(qRound(0.3 * qRed(c_rgb) + 0.59 * qGreen(c_rgb) + 0.11 * qBlue(c_rgb)), 255);
qi.setPixel(i, j, qRgba(k, k, k, qAlpha(c_rgb)));
}
}
*pm=QPixmap::fromImage(qi);
}
Eigen::Matrix<T,4,1> rotate_to_plane(Eigen::Matrix<T,4,1> normP,
Eigen::Matrix<T,4,1> norm,
Eigen::Matrix<T,4,1> cen,
Eigen::Matrix<T,4,1> vec){
norm.normalize();
normP.normalize();
Eigen::Matrix<T,4,1> xe = cross(norm,normP).normalize();
T r1 = norm.mag();
T rP = normP.mag();
T o = acos(dot(normP,norm)/r1/rP) - M_PI;
T o0 = acos(dot(normP,norm)/r1/rP);
Eigen::Quaternion<T> qP(normP);
Eigen::Quaternion<T> qi(norm);
// Eigen::Quaternion<T> dq = (qP-qi).normalize();
Eigen::Quaternion<T> dq(cos(o/2.), sin(o/2.)*xe[0], sin(o/2.)*xe[1], sin(o/2.)*xe[2]);
// Eigen::Quaternion<T> dq = qP*qi.conj()*qP;
Eigen::Matrix<T,4,1> c = dq.normalize().rotate(vec - cen);
return c;
}
void pick_generic_node( node_t *n, const Imath::V2f& p, const composition_view_t& view, pick_result_t& result)
{
result.node = 0;
result.component = pick_result_t::no_pick;
result.plug_num = -1;
if( ( p.x < n->location().x) || (p.x > n->location().x + generic_node_width( n)))
return;
if( ( p.y < n->location().y - 6.0) || ( p.y > n->location().y + generic_node_height() + 5))
return;
result.node = n;
result.component = pick_result_t::body_picked;
Imath::V2f q( generic_output_location( n));
Imath::V2i pi( view.world_to_screen( p));
Imath::V2i qi( view.world_to_screen( q));
if( ( pi - qi).length2() < 25)
{
result.component = pick_result_t::output_picked;
result.plug_num = 0;
return;
}
for( unsigned int i=0;i<n->num_inputs();++i)
{
q = generic_input_location( n, i);
qi = view.world_to_screen( q);
if( ( pi - qi).length2() < 25)
{
result.component = pick_result_t::input_picked;
result.plug_num = i;
return;
}
}
}
void
TrPlanestressRotAllman :: computeEgdeNMatrixAt(FloatMatrix &answer, int iedge, GaussPoint *gp)
{
std::vector< FloatArray > lxy;
FloatArray l, n;
IntArray en;
FEI2dTrQuad qi(1, 2);
this->computeLocalNodalCoordinates(lxy); // get ready for tranformation into 3d
qi.edgeEvalN( n, iedge, gp->giveNaturalCoordinates(), FEIVertexListGeometryWrapper(lxy) );
qi.computeLocalEdgeMapping(en, iedge); // get edge mapping
this->interp.edgeEvalN( l, iedge, gp->giveNaturalCoordinates(), FEIElementGeometryWrapper(this) );
answer.resize(3, 6);
answer.at(1, 1) = answer.at(2, 2) = n.at(1) + n.at(3) / 2.0;
answer.at(1, 4) = answer.at(2, 5) = n.at(2) + n.at(3) / 2.0;
answer.at(1, 3) = n.at(3) * ( lxy [ en.at(2) - 1 ].at(2) - lxy [ en.at(1) - 1 ].at(2) ) / 8.0;
answer.at(1, 6) = -answer.at(1, 3);
answer.at(2, 3) = n.at(3) * ( lxy [ en.at(2) - 1 ].at(1) - lxy [ en.at(1) - 1 ].at(1) ) / 8.0;
answer.at(2, 6) = -answer.at(2, 3);
answer.at(3, 3) = l.at(1);
answer.at(3, 6) = l.at(2);
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
TEST(UtilsTest, toTextureImageRegion_emptyRegion)
{
QImage qi(3, 4, QImage::Format_ARGB32);
{
cvf::TextureImage i;
cvfqt::Utils::toTextureImageRegion(qi, cvf::Vec2ui(1, 1), cvf::Vec2ui(0, 0), &i);
EXPECT_EQ(0, i.width());
EXPECT_EQ(0, i.height());
}
{
cvf::TextureImage i;
cvfqt::Utils::toTextureImageRegion(qi, cvf::Vec2ui(1, 1), cvf::Vec2ui(1, 0), &i);
EXPECT_EQ(0, i.width());
EXPECT_EQ(0, i.height());
}
{
cvf::TextureImage i;
cvfqt::Utils::toTextureImageRegion(qi, cvf::Vec2ui(1, 1), cvf::Vec2ui(0, 1), &i);
EXPECT_EQ(0, i.width());
EXPECT_EQ(0, i.height());
}
}
QPixmap loadIcon(const QString nam, bool forceUseColor)
{
static ScPixmapCache<QString> pxCache;
if (pxCache.contains(nam))
return *pxCache[nam];
QString iconFilePath(QString("%1%2").arg(ScPaths::instance().iconDir()).arg(nam));
QPixmap *pm = new QPixmap();
if (!QFile::exists(iconFilePath))
qWarning("Unable to load icon %s: File not found", iconFilePath.toAscii().constData());
else
{
pm->load(iconFilePath);
if (pm->isNull())
qWarning("Unable to load icon %s: Got null pixmap", iconFilePath.toAscii().constData());
if (PrefsManager::instance()->appPrefs.grayscaleIcons && !forceUseColor)
{
QImage qi(pm->toImage());
int h=qi.height();
int w=qi.width();
QRgb c_rgb;
for (int i=0;i<w;++i)
{
for (int j=0;j<h;++j)
{
c_rgb=qi.pixel(i,j);
int k = qMin(qRound(0.3 * qRed(c_rgb) + 0.59 * qGreen(c_rgb) + 0.11 * qBlue(c_rgb)), 255);
qi.setPixel(i, j, qRgba(k, k, k, qAlpha(c_rgb)));
}
}
*pm=QPixmap::fromImage(qi);
}
}
pxCache.insert(nam, pm);
return *pm;
}
/// \brief Two dimensional midpoint displacement fractal.
///
/// For a tile where edges are to be filled by 1d fractals.
/// Size must be a power of 2, array is (size + 1) * (size + 1) with the
/// corners the control points.
void Segment::fill2d(const BasePoint& p1, const BasePoint& p2,
const BasePoint& p3, const BasePoint& p4)
{
assert(m_points!=0);
// int line = m_res+1;
// calculate the edges first. This is necessary so that segments tile
// seamlessly note the order in which the edges are calculated and the
// direction. opposite edges are calculated the same way (eg left->right)
// so that the top of one tile matches the bottom of another, likewise
// with sides.
// temporary array used to hold each edge
float * edge = new float[m_size];
// calc top edge and copy into m_points
fill1d(p1,p2,edge);
for (int i=0;i<=m_res;i++) {
m_points[0*m_size + i] = edge[i];
checkMaxMin(edge[i]);
}
// calc left edge and copy into m_points
fill1d(p1,p4,edge);
for (int i=0;i<=m_res;i++) {
m_points[i*m_size + 0] = edge[i];
checkMaxMin(edge[i]);
}
// calc right edge and copy into m_points
fill1d(p2,p3,edge);
for (int i=0;i<=m_res;i++) {
m_points[i*m_size + m_res] = edge[i];
checkMaxMin(edge[i]);
}
// calc bottom edge and copy into m_points
fill1d(p4,p3,edge);
for (int i=0;i<=m_res;i++) {
m_points[m_res*m_size + i] = edge[i];
checkMaxMin(edge[i]);
}
// seed the RNG - this is the 5th and last seeding for the tile.
// it was seeded once for each edge, now once for the tile.
//srand(p1.seed()*20 + p2.seed()*15 + p3.seed()*10 + p4.seed()*5);
WFMath::MTRand::uint32 seed[4]={ p1.seed(), p2.seed(), p3.seed(), p4.seed() };
WFMath::MTRand rng(seed, 4);
QuadInterp qi(m_res, p1.roughness(), p2.roughness(), p3.roughness(), p4.roughness());
float f = BasePoint::FALLOFF;
float depth=0;
// center of m_points is done separately
int stride = m_res/2;
//float roughness = (p1.roughness+p2.roughness+p3.roughness+p4.roughness)/(4.0f);
float roughness = qi.calc(stride, stride);
m_points[stride*m_size + stride] = qRMD(rng, m_points[0 * m_size + stride],
m_points[stride*m_size + 0],
m_points[stride*m_size + m_res],
m_points[m_res*m_size + stride],
roughness,
f, depth);
checkMaxMin(m_points[stride*m_size + stride]);
stride >>= 1;
// skip across the m_points and fill in the points
// alternate cross and plus shapes.
// this is a diamond-square algorithm.
while (stride) {
//Cross shape - + contributes to value at X
//+ . +
//. X .
//+ . +
for (int i=stride;i<m_res;i+=stride*2) {
for (int j=stride;j<m_res;j+=stride*2) {
roughness=qi.calc(i,j);
m_points[j*m_size + i] = qRMD(rng, m_points[(i-stride) + (j+stride) * (m_size)],
m_points[(i+stride) + (j-stride) * (m_size)],
m_points[(i+stride) + (j+stride) * (m_size)],
m_points[(i-stride) + (j-stride) * (m_size)],
roughness, f, depth);
checkMaxMin(m_points[j*m_size + i]);
}
}
depth++;
//Plus shape - + contributes to value at X
//. + .
//+ X +
//. + .
for (int i=stride*2;i<m_res;i+=stride*2) {
for (int j=stride;j<m_res;j+=stride*2) {
roughness=qi.calc(i,j);
m_points[j*m_size + i] = qRMD(rng, m_points[(i-stride) + (j) * (m_size)],
m_points[(i+stride) + (j) * (m_size)],
m_points[(i) + (j+stride) * (m_size)],
m_points[(i) + (j-stride) * (m_size)],
roughness, f , depth);
checkMaxMin(m_points[j*m_size + i]);
}
}
for (int i=stride;i<m_res;i+=stride*2) {
for (int j=stride*2;j<m_res;j+=stride*2) {
roughness=qi.calc(i,j);
m_points[j*m_size + i] = qRMD(rng, m_points[(i-stride) + (j) * (m_size)],
m_points[(i+stride) + (j) * (m_size)],
m_points[(i) + (j+stride) * (m_size)],
m_points[(i) + (j-stride) * (m_size)],
roughness, f, depth);
checkMaxMin(m_points[j*m_size + i]);
}
}
stride>>=1;
depth++;
}
delete [] edge;
}
int Stroke::occluders_size() const
{
return qi();
}
int Curve::occluders_size() const
{
return qi();
}
bool add(control_ptr ob, long i, long j, T teni, T tenj){
// m2::subdivide<T> sub;
// m2Ch = sub.subdivide_control(m2Ch);
//bezier_curve<point_space<3,T> > mCurve(3);
face_ptr fi = ob->face(i);
face_ptr fj = ob->face(j);
bezier_curve<point_space<3,typename SPACE::type> > mCurve(4);
coordinate_type c0 = fi->calculate_center();
coordinate_type c0t = c0 + teni*ob->face(i)->normal();
coordinate_type c1 = fj->calculate_center();
coordinate_type c1t = c1 + tenj*ob->face(j)->normal();
if (fi->size() != fj->size() ) {
return false;
}
mCurve.push_point(c0);
mCurve.push_point(c0t);
mCurve.push_point(c1t);
mCurve.push_point(c1);
mCurve.update_knot_vector();
Eigen::Quaternion<T> q1(ob->face(j)->normal());q1.normalize();
vector<coordinate_type > f0 = fi->coordinate_trace();
vector<coordinate_type > f1 = fj->coordinate_trace();
long Ni = mCurve.mKnots.size();
T dt = T(1./T(Ni-1));
T t = dt*0.5;
// for(long ii = 0; ii < 3; ++ii){
for(long ii = 0; ii < Ni-1; ++ii){
coordinate_type Ni = fi->normal();
Eigen::Quaternion<T> q0(Ni); q0.normalize();
coordinate_type de = mCurve.mKnots[ii]-mCurve.mKnots[ii+1];
de.normalize();
Eigen::Quaternion<T> qi(de); qi.normalize();
//
coordinate_type xe = cross(Ni,-de).normalize();
T r0 = de.mag();
T r1 = Ni.mag();
T o = acos(dot(-de,Ni)/r0/r1);
Eigen::Quaternion<T> dq(cos(o/2.), sin(o/2.)*xe[0], sin(o/2.)*xe[1], sin(o/2.)*xe[2]);
// Eigen::Quaternion<T> dq = (qi*q0); //dq[0]*=M_PI;
//dq.normalize();
coordinate_type cen = fi->calculate_center();
face_vertex_ptr itb = fi->fbegin();
face_vertex_ptr ite = fi->fend();
construct<SPACE> bevel;
bevel.bevel_face(ob, fi, 0.0, 0.0);
bool at_head = false;
while (!at_head) {
at_head = itb == ite;
coordinate_type c = itb->coordinate();
coordinate_type cp0 = dq.rotate(c-cen);
itb->coordinate() = cp0 + (mCurve.mKnots[ii+1]);
itb = itb->next();
}
fi->update_normal();
fi->update_center();
this->slerp_face(t, fi, fj);
// cen = fi->calculate_center();
// itb = fi->fbegin();
// at_head = false;
// while (!at_head) {
// at_head = itb == ite;
// coordinate_type c = itb->coordinate();
// coordinate_type N = fi->normal();
// T o = 0.5*t*M_PI;
// Eigen::Quaternion<T> qb(cos(o*0.5), sin(o*0.5)*N[0], sin(o*0.5)*N[1], sin(o*0.5)*N[2]);
// qb.normalize();
// Eigen::Matrix<T,4,1> cp1 = qb.rotate(c-cen);
// // Eigen::Matrix<T,4,1> cp1 = cp0;
// // itb->coordinate() = cp0 + (mCurve.mKnots[ii] + mCurve.mKnots[ii + 1])*0.5;
// itb->coordinate() = cp1 + (mCurve.mKnots[ii+1]);
// itb = itb->next();
// }
t += dt;
}
graph_skinning<SPACE> gs; //TODO: stitch_faces needs to get moved to a surgery object
gs.stitch_faces(ob, fi, fj, 0.01);
return true;
}
int main(int argc, char **argv) {
const std::string storage_path = "exampledb";
// comment that, for open exists storage.
if (dariadb::utils::fs::path_exists(storage_path)) {
dariadb::utils::fs::rm(storage_path);
}
// Replace standart logger.
dariadb::utils::ILogger_ptr log_ptr{new QuietLogger()};
dariadb::utils::LogManager::start(log_ptr);
auto storage = dariadb::open_storage(storage_path);
auto settings = storage->settings();
auto scheme = dariadb::scheme::Scheme::create(settings);
auto p1 = scheme->addParam("group.param1");
auto p2 = scheme->addParam("group.subgroup.param2");
scheme->save();
auto m = dariadb::Meas();
auto start_time = dariadb::timeutil::current_time();
// write values in interval [currentTime:currentTime+10]
m.time = start_time;
for (size_t i = 0; i < 10; ++i) {
if (i % 2) {
m.id = p1;
} else {
m.id = p2;
}
m.time++;
m.value++;
m.flag = 100 + i % 2;
auto status = storage->append(m);
if (status.writed != 1) {
std::cerr << "Error: " << dariadb::to_string(status.error) << std::endl;
}
}
// we can get param id`s from scheme
auto all_params = scheme->ls();
dariadb::IdArray all_id;
all_id.reserve(all_params.size());
all_id.push_back(all_params.idByParam("group.param1"));
all_id.push_back(all_params.idByParam("group.subgroup.param2"));
// query writed interval;
dariadb::QueryInterval qi(all_id, dariadb::Flag(), start_time, m.time);
dariadb::MeasArray readed_values = storage->readInterval(qi);
std::cout << "Readed: " << readed_values.size() << std::endl;
for (auto measurement : readed_values) {
std::cout << " param: " << all_params[measurement.id]
<< " timepoint: " << dariadb::timeutil::to_string(measurement.time)
<< " value:" << measurement.value << std::endl;
}
// query in timepoint;
dariadb::QueryTimePoint qp(all_id, dariadb::Flag(), m.time);
dariadb::Id2Meas timepoint = storage->readTimePoint(qp);
std::cout << "Timepoint: " << std::endl;
for (auto kv : timepoint) {
auto measurement = kv.second;
std::cout << " param: " << all_params[kv.first]
<< " timepoint: " << dariadb::timeutil::to_string(measurement.time)
<< " value:" << measurement.value << std::endl;
}
// current values
dariadb::Id2Meas cur_values = storage->currentValue(all_id, dariadb::Flag());
std::cout << "Current: " << std::endl;
for (auto kv : timepoint) {
auto measurement = kv.second;
std::cout << " id: " << all_params[kv.first]
<< " timepoint: " << dariadb::timeutil::to_string(measurement.time)
<< " value:" << measurement.value << std::endl;
}
// callback
std::cout << "Callback in interval: " << std::endl;
Callback callback;
storage->foreach (qi, &callback);
callback.wait();
// callback
std::cout << "Callback in timepoint: " << std::endl;
storage->foreach (qp, &callback);
callback.wait();
{ // stat
auto stat = storage->stat(dariadb::Id(0), start_time, m.time);
std::cout << "count: " << stat.count << std::endl;
std::cout << "time: [" << dariadb::timeutil::to_string(stat.minTime) << " "
<< dariadb::timeutil::to_string(stat.maxTime) << "]" << std::endl;
std::cout << "val: [" << stat.minValue << " " << stat.maxValue << "]" << std::endl;
std::cout << "sum: " << stat.sum << std::endl;
}
{ // statistical functions
dariadb::statistic::Calculator calc(storage);
auto all_functions = dariadb::statistic::FunctionFactory::functions();
std::cout << "available functions: " << std::endl;
for (auto fname : all_functions) {
std::cout << " " << fname << std::endl;
}
auto result =
calc.apply(dariadb::Id(0), start_time, m.time, dariadb::Flag(), all_functions);
for (size_t i = 0; i < result.size(); ++i) {
auto measurement = result[i];
std::cout << all_functions[i] << " id: " << all_params[m.id].name
<< " timepoint: " << dariadb::timeutil::to_string(measurement.time)
<< " value:" << measurement.value << std::endl;
}
}
}
MaxCutHyperheuristic::MaxCutHyperheuristic(const MaxCutInstance&mi,
double runtime_limit,
bool validation,
MaxCutCallback *mc, int seed,
std::string* selected) :
MaxCutHeuristic(mi, runtime_limit, validation, mc) {
// Step 1: Calculate graph metrics for this instance.
GraphMetrics gm(mi);
std::vector<double> metrics;
gm.AllMetrics(&metrics, NULL);
// Step 2: Obtain predicted probabilities from each random forest model.
// Best-performing model information (using streaming alg to select best)
double bestProbability = -1.0;
Prob bestProblem = MaxCut;
std::string bestCode = "";
int numBest = 1; // Number tied for best
// Check the Max-Cut heuristics
HeuristicFactory factory;
std::vector<std::string> codes;
factory.MaxCutHeuristicCodes(&codes);
for (int i=0; i < codes.size(); ++i) {
UpdateBestModel(codes[i], MaxCut, metrics, &bestProbability, &bestProblem,
&bestCode, &numBest);
}
// Check the QUBO heuristics
factory.QUBOHeuristicCodes(&codes);
for (int i=0; i < codes.size(); ++i) {
UpdateBestModel(codes[i], QUBO, metrics, &bestProbability, &bestProblem,
&bestCode, &numBest);
}
if (selected) {
*selected = bestCode;
}
// Step 3: Run the selected heuristic "H", using callbacks to capture all the
// reported solutions from "H" and report them for the hyper-heuristic.
// Because several previous steps may have used random draws or set the
// random seed, re-set the seed to the original here.
srand(seed);
if (bestProblem == MaxCut) {
// Using a Max-Cut heuristic
HyperheuristicMaxCutCallback callback(this);
// Run with our callback and no validation (solutions will be validated
// with the hyperheuristic, so no need to double validate)
Heuristic *h = factory.RunMaxCutHeuristic(bestCode, mi, runtime_limit,
false, &callback);
delete h; // We don't need to keep around the pointer
} else if (bestProblem == QUBO) {
// Using a QUBO heuristic
HyperheuristicQUBOCallback callback(this, mi);
QUBOInstance qi(mi); // Need to construct a QUBOInstance for heuristic
// Run with our callback and no validation (solutions will be validated
// with the hyperheuristic, so no need to double validate)
Heuristic *h = factory.RunQUBOHeuristic(bestCode, qi, runtime_limit,
false, &callback);
delete h; // We don't need to keep around the pointer
}
}
