void
Spring::paintEvent(QPaintEvent *ev)
{
if (!designMode())
return;
QPainter p(this);
p.setRenderHint(QPainter::Antialiasing, true);
//! @todo p.setPen(QPen(Qt::white, 1));
//! @todo p.setCompositionMode(QPainter::CompositionMode_Xor);
if (m_orient == Qt::Vertical) {
uint part = (height() + 16) / 16;
if (part < 3)
part = 3;
uint w = width() - 1;
uint offset = 0;
for (uint i = 0; i < 4; i++, offset += (part * 4)) {
QPolygon poly1(4);
poly1.putPoints(0, 4,
w / 2, offset, w, offset + part, w, offset + part, w / 2, offset + part*2);
QPainterPath ppath1;
ppath1.addPolygon(poly1);
p.strokePath(ppath1, p.pen());
QPolygon poly2(4);
poly2.putPoints(0, 4,
w / 2, offset + part*2, 0, offset + part*3, 0, offset + part*3, w / 2, offset + part*4);
QPainterPath ppath2;
ppath2.addPolygon(poly2);
p.strokePath(ppath2, p.pen());
}
} else {
uint part = (width() + 16) / 16;
if (part < 3)
part = 3;
uint h = height() - 1;
uint offset = 0;
for (uint i = 0; i < 4; i++, offset += (part * 4)) {
QPolygon poly1(4);
poly1.putPoints(0, 4,
offset, h / 2, offset + part, 0, offset + part, 0, offset + part*2, h / 2);
QPainterPath ppath1;
ppath1.addPolygon(poly1);
p.strokePath(ppath1, p.pen());
QPolygon poly2(4);
poly2.putPoints(0, 4,
offset + part*2, h / 2, offset + part*3, h, offset + part*3, h, offset + part*4, h / 2);
QPainterPath ppath2;
ppath2.addPolygon(poly2);
p.strokePath(ppath2, p.pen());
}
}
}
int main()
{
Poly<int> poly1(2);
poly1[0] = 1;
poly1[1] = 2;
poly1[2] = 10;
Poly<int> poly2(3);
poly2[0] = 1;
poly2[1] = 2;
poly2[2] = 10;
poly2[3] = 5;
poly1.view();
poly2.view();
auto result1 = poly1 + poly2;
auto result2 = poly1 * poly2;
result1.view();
result2.view();
std::cout << std::endl << std::endl;
return 0;
}
int main(int argc, char **argv){
if(argc < 3){
std::cout<<"Not enough arguments"<<std::endl;
return -1;
}
int POLYTERMS = atoi(argv[2]);
if(POLYTERMS < 2 || (POLYTERMS & (POLYTERMS - 1))){
std::cout<<"Problem size must be a power of 2\n";
return -1;
}
std::mt19937 rng(time(NULL));
std::uniform_real_distribution<> dist(-1, 1);
std::vector<float> times;
for(int i = 0; i < 10; ++i){
std::vector<float> poly1(POLYTERMS), poly2(POLYTERMS);
std::generate(poly1.begin(), poly1.end(), [&](){return dist(rng);});
std::generate(poly2.begin(), poly2.end(), [&](){return dist(rng);});
std::vector<float> temp;
auto start = std::chrono::steady_clock::now();
switch(argv[1][1]){
case 'd': temp = dumbMult(poly1, poly2); break;
case '4': temp = fourMult(poly1, poly2); break;
case '3': temp = threeMult(poly1, poly2); break;
default: "Invalid algorithm argument\n"; return -1;
}
times.push_back(std::chrono::duration_cast<std::chrono::duration<float>>(std::chrono::steady_clock::now() - start).count());
// std::cout<<"Ran in "<<(std::chrono::duration_cast<std::chrono::duration<float>>(std::chrono::steady_clock::now() - start).count())<<" seconds"<<std::endl;
}
std::cout<<"Mean time: "<<(std::accumulate(times.begin(), times.end(), 0.0) / times.size())<<" seconds"<<std::endl;
// std::cout<<"Resulting coefficients: ";
// for(auto &term : temp){
// std::cout<<term<<" ";
// }
// std::cout<<std::endl;
}
int point_proche(int16 table[][2]) {
int x1, y1, i, x, y, p;
int d1 = 1000;
_vm->_polyStructs = &_vm->_polyStructNorm;
if (nclick_noeud == 1) {
x = x_mouse;
y = y_mouse;
x1 = table_ptselect[0][0];
y1 = table_ptselect[0][1];
_vm->_polyStructs = &_vm->_polyStructExp;
getPixel(x, y);
if (!flag_obstacle) {
_vm->_polyStructs = &_vm->_polyStructNorm;
getPixel(x, y);
if (flag_obstacle) {
polydroite(x1, y1, x, y);
}
_vm->_polyStructs = &_vm->_polyStructExp;
}
if (!flag_obstacle) { /* dans flag_obstacle --> couleur du point */
x1 = table_ptselect[0][0];
y1 = table_ptselect[0][1];
poly2(x, y, x1, y1);
x_mouse = X;
y_mouse = Y;
}
}
_vm->_polyStructs = &_vm->_polyStructNorm;
p = -1;
for (i = 0; i < ctp_routeCoordCount; i++) {
x = table[i][0];
y = table[i][1];
int pointDistance = computeDistance(x_mouse, y_mouse, x, y);
if (pointDistance < d1) {
polydroite(x_mouse, y_mouse, x, y);
if (!flag_obstacle && ctp_routes[i][0] > 0) {
d1 = pointDistance;
p = i;
}
}
}
return (p);
}
TESSLINE* ApproximateOutline(bool allow_detailed_fx, C_OUTLINE* c_outline) {
TBOX loop_box; // bounding box
inT32 area; // loop area
EDGEPT stack_edgepts[FASTEDGELENGTH]; // converted path
EDGEPT* edgepts = stack_edgepts;
// Use heap memory if the stack buffer is not big enough.
if (c_outline->pathlength() > FASTEDGELENGTH)
edgepts = new EDGEPT[c_outline->pathlength()];
loop_box = c_outline->bounding_box();
area = loop_box.height();
if (!poly_wide_objects_better && loop_box.width() > area)
area = loop_box.width();
area *= area;
edgesteps_to_edgepts(c_outline, edgepts);
fix2(edgepts, area);
EDGEPT* edgept = poly2(edgepts, area); // 2nd approximation.
EDGEPT* startpt = edgept;
EDGEPT* result = NULL;
EDGEPT* prev_result = NULL;
do {
EDGEPT* new_pt = new EDGEPT;
new_pt->pos = edgept->pos;
new_pt->prev = prev_result;
if (prev_result == NULL) {
result = new_pt;
} else {
prev_result->next = new_pt;
new_pt->prev = prev_result;
}
if (allow_detailed_fx) {
new_pt->src_outline = edgept->src_outline;
new_pt->start_step = edgept->start_step;
new_pt->step_count = edgept->step_count;
}
prev_result = new_pt;
edgept = edgept->next;
}
while (edgept != startpt);
prev_result->next = result;
result->prev = prev_result;
if (edgepts != stack_edgepts)
delete [] edgepts;
return TESSLINE::BuildFromOutlineList(result);
}
// This computes Chen and Han's magic polynomial G, which
// has the property that G(x) = (x mod p) (mod p^e).
// Here, (x mod p) is in the interval [0,1] if p == 2,
// and otherwise, is in the interval (-p/2, p/2).
static
void compute_magic_poly(ZZX& poly1, long p, long e)
{
FHE_TIMER_START;
Vec<ZZ> a;
compute_a_vals(a, p, e);
ZZ p_to_e = power_ZZ(p, e);
long len = (e-1)*(p-1)+2;
ZZ_pPush push(p_to_e);
ZZ_pX poly(0);
ZZ_pX term(1);
ZZ_pX X(INIT_MONO, 1);
poly = 0;
term = 1;
for (long m = 0; m < p; m++) {
term *= (X-m);
}
for (long m = p; m < len; m++) {
poly += term * conv<ZZ_p>(a[m]);
term *= (X-m);
}
// replace poly by poly(X+(p-1)/2) for odd p
if (p % 2 == 1) {
ZZ_pX poly2(0);
for (long i = deg(poly); i >= 0; i--)
poly2 = poly2*(X+(p-1)/2) + poly[i];
poly = poly2;
}
poly = X - poly;
poly1 = conv<ZZX>(poly);
}
void valide_noeud(int16 table[], int16 p, int *nclick, int16 solution0[20 + 3][2]) {
int a, b, d, i, p1, x1, x2, y1, y2;
//int y=30;
table[*nclick] = p;
table[(*nclick) + 1] = -1;
table_ptselect[*nclick][0] = x_mouse;
table_ptselect[*nclick][1] = y_mouse;
(*nclick)++;
_vm->_polyStructs = &_vm->_polyStructNorm;
if (*nclick == 2) { // second point
x1 = table_ptselect[0][0];
y1 = table_ptselect[0][1];
x2 = table_ptselect[1][0];
y2 = table_ptselect[1][1];
if ((x1 == x2) && (y1 == y2)) {
return;
}
flag_aff_chemin = 1;
_vm->_polyStructs = &_vm->_polyStructExp;
// can we go there directly ?
polydroite(x1, y1, x2, y2);
if (!flag_obstacle) {
solution0[0][0] = x1;
solution0[0][1] = y1;
_vm->_polyStructs = &_vm->_polyStructExp;
poly2(x2, y2, ctp_routeCoords[select_noeud[1]][0],
ctp_routeCoords[select_noeud[1]][1]);
solution0[1][0] = table_ptselect[1][0] = X;
solution0[1][1] = table_ptselect[1][1] = Y;
solution0[2][0] = -1;
if ((x1 == X) && (y1 == Y)) {
flag_aff_chemin = 0;
return;
}
} else {
// no, we take the fastest way
solution[0] = -1;
if (ctp_routes[select_noeud[0]][0] > 0)
chemin0(table[0], table[1]);
if (solution[0] == -1) {
x1 = table_ptselect[0][0];
y1 = table_ptselect[0][1];
polydroite(x1, y1, x_mouse, y_mouse);
solution0[0][0] = x1;
solution0[0][1] = y1;
solution0[1][0] = X;
solution0[1][1] = Y;
solution0[2][0] = -1;
if ((x1 == X) && (y1 == Y)) {
flag_aff_chemin = 0;
return;
}
} else {
solution0[0][0] = x1;
solution0[0][1] = y1;
i = 0;
while (solution[i] != -1) {
p1 = solution[i];
solution0[i + 1][0] =
ctp_routeCoords[p1][0];
solution0[++i][1] =
ctp_routeCoords[p1][1];
}
_vm->_polyStructs = &_vm->_polyStructExp;
poly2(x2, y2,
ctp_routeCoords[select_noeud[1]][0],
ctp_routeCoords[select_noeud[1]][1]);
solution0[i + 1][0] = table_ptselect[1][0] = X;
solution0[i + 1][1] = table_ptselect[1][1] = Y;
solution0[i + 2][0] = -1;
if ((x1 == X) && (y1 == Y)) {
flag_aff_chemin = 0;
return;
}
/****** Trim down any un-necessary walk points ******/
i++;
d = 0;
a = i;
flag_obstacle = 1;
while (d != a) {
x1 = solution0[d][0];
y1 = solution0[d][1];
while (flag_obstacle && i != d) {
x2 = solution0[i][0];
y2 = solution0[i][1];
_vm->_polyStructs = &_vm->_polyStructExp;
polydroite(x1, y1, x2, y2);
i--;
}
flag_obstacle = 1;
if (d != i) {
i++;
for (b = d + 1; b < i; b++) {
solution0[b][0] = -2;
}
} else
i++;
d = i;
i = a;
}
flag_obstacle = 0;
}
}
}
}
virtual void on_draw() {
typedef agg::renderer_base<pixfmt> ren_base;
pixfmt pixf(rbuf_window());
ren_base renb(pixf);
renb.clear(agg::rgba(1, 1, 1));
agg::rasterizer_scanline_aa<> ras;
agg::scanline_p8 sl;
agg::path_storage path;
path.move_to(m_x[0], m_y[0]);
path.line_to((m_x[0] + m_x[1]) / 2,
(m_y[0] + m_y[1]) / 2); // This point is added only to check
// for numerical stability
path.line_to(m_x[1], m_y[1]);
path.line_to(m_x[2], m_y[2]);
path.line_to(m_x[2], m_y[2]); // This point is added only to check for
// numerical stability
path.move_to((m_x[0] + m_x[1]) / 2, (m_y[0] + m_y[1]) / 2);
path.line_to((m_x[1] + m_x[2]) / 2, (m_y[1] + m_y[2]) / 2);
path.line_to((m_x[2] + m_x[0]) / 2, (m_y[2] + m_y[0]) / 2);
path.close_polygon();
agg::line_cap_e cap = agg::butt_cap;
if (m_cap.cur_item() == 1) cap = agg::square_cap;
if (m_cap.cur_item() == 2) cap = agg::round_cap;
agg::line_join_e join = agg::miter_join;
if (m_join.cur_item() == 1) join = agg::miter_join_revert;
if (m_join.cur_item() == 2) join = agg::round_join;
if (m_join.cur_item() == 3) join = agg::bevel_join;
// (1)
agg::conv_stroke<agg::path_storage> stroke(path);
stroke.line_join(join);
stroke.line_cap(cap);
stroke.miter_limit(m_miter_limit.value());
stroke.width(m_width.value());
ras.add_path(stroke);
agg::render_scanlines_aa_solid(ras, sl, renb, agg::rgba(0.8, 0.7, 0.6));
// (1)
// (2)
agg::conv_stroke<agg::path_storage> poly1(path);
poly1.width(1.5);
ras.add_path(poly1);
agg::render_scanlines_aa_solid(ras, sl, renb, agg::rgba(0, 0, 0));
// (2)
// (3)
agg::conv_dash<agg::conv_stroke<agg::path_storage> > poly2_dash(stroke);
agg::conv_stroke<agg::conv_dash<agg::conv_stroke<agg::path_storage> > >
poly2(poly2_dash);
poly2.miter_limit(4.0);
poly2.width(m_width.value() / 5.0);
poly2.line_cap(cap);
poly2.line_join(join);
poly2_dash.add_dash(20.0, m_width.value() / 2.5);
ras.add_path(poly2);
agg::render_scanlines_aa_solid(ras, sl, renb, agg::rgba(0, 0, 0.3));
// (3)
// (4)
ras.add_path(path);
agg::render_scanlines_aa_solid(ras, sl, renb,
agg::rgba(0.0, 0.0, 0.0, 0.2));
// (4)
agg::render_ctrl(ras, sl, renb, m_join);
agg::render_ctrl(ras, sl, renb, m_cap);
agg::render_ctrl(ras, sl, renb, m_width);
agg::render_ctrl(ras, sl, renb, m_miter_limit);
}
void skeleton_mul::smoothEachBranch() {
smoothedBrchPts.clear() ;
smoothedBrchPts.resize(brchPts.size()) ;
for( int i=0; i<brchPts.size(); ++i ){
if( brchPts[i].size()< 4 ){
while( brchPts[i].size() < 4 ){
std::vector<Point3f> tmp ;
for( int j=0; j< brchPts[i].size()-1; ++j ){
tmp.push_back( brchPts[i][j] ) ;
tmp.push_back( (brchPts[i][j]+brchPts[i][j+1])/2 ) ;
}
tmp.push_back( brchPts[i].back() ) ;
brchPts[i] = tmp ;
}
}
std::vector<double> x, y, z, t ;
for( int j=0; j<brchPts[i].size(); ++j){
x.push_back(brchPts[i][j].X() );
y.push_back(brchPts[i][j].Y() );
z.push_back(brchPts[i][j].Z() );
t.push_back( (double)j/(brchPts[i].size()-1) ) ;
}
Spline3Interp poly1( t, x);
poly1.calcCoefs();
std::vector<double> px,py, pz ;
for( double t=0.0; t<1.0; t+=0.0005 )
px.push_back(poly1.evaluate(t)) ;
px.push_back(poly1.evaluate(1.0)) ;
Spline3Interp poly2( t, y);
poly2.calcCoefs();
for( double t=0.0; t<1.0; t+=0.0005 )
py.push_back(poly2.evaluate(t)) ;
py.push_back(poly2.evaluate(1.0)) ;
Spline3Interp poly3( t, z);
poly3.calcCoefs();
for( double t=0.0; t<1.0; t+=0.0005 )
pz.push_back(poly3.evaluate(t)) ;
pz.push_back(poly3.evaluate(1.0)) ;
for( int id=0; id<px.size(); ++id )
smoothedBrchPts[i].push_back( Point3f(px[id], py[id], pz[id]) ) ;
}
for( int i=0; i<smoothedBrchPts.size() ; ++i ){
for( int j=1; j<smoothedBrchPts[i].size()-1; ++j ){
if( (smoothedBrchPts[i][j-1] - smoothedBrchPts[i][j]).Norm() < ReconstructorPara::branchSampleStep ){
smoothedBrchPts[i].erase( smoothedBrchPts[i].begin()+j) ;
j-- ;
}
if( (smoothedBrchPts[i][smoothedBrchPts[i].size()-1] - smoothedBrchPts[i][smoothedBrchPts[i].size()-2]).Norm() < ReconstructorPara::branchSampleStep * 0.5)
smoothedBrchPts[i].erase( smoothedBrchPts[i].begin()+smoothedBrchPts[i].size()-2) ;
}
}
}
int main(int argc, char *argv[])
{
//check fit
printf("Polynomial fit test:\n");
std::vector<float> x, y;
for(int i = 0; i < 10; i++) {
float p_x = float(i);
float p_y = 3.0f * p_x * p_x + 2.0f * p_x + 1.0f;
x.push_back(p_x);
y.push_back(p_y);
}
pic::Polynomial poly;
poly.fit(x, y, 2);
poly.print();
printf("p(4.0f) = %f\n", poly.eval(4.0f));
float roots[2];
bool bReal = poly.getAllRoots(roots);
if(bReal) {
printf("Roots: %f %f\n", roots[0], roots[1]);
} else {
printf("No Real roots!\n");
}
printf("\n\n");
printf("Second order polynomial test:\n");
float tmp[] = {1.0f, -3.0f, 0.5f};
pic::Polynomial poly2(tmp, 3);
poly2.print();
printf("p(0.0f) = %f\n", poly2.eval(0.0f));
printf("dp(1.0f) = %f\n", poly2.dEval(1.0f));
bReal = poly2.getRoots(roots);
if(bReal) {
printf("Roots: %f %f\n", roots[0], roots[1]);
} else {
printf("No Real roots!\n");
}
printf("\n\n");
printf("Third order polynomial test:\n");
float tmp3[] = {-6.0f, 11.0f, -6.0f, 1.0f};
pic::Polynomial poly3(tmp3, 4);
poly3.print();
float r;
auto poly3_2 = poly3.horner(3.0f, r);
printf("H: %s R: %f\n", poly3_2.toString().c_str(), r);;
printf("p(1.0f) = %f\n", poly3.eval(1.0f));
printf("dp(1.0f) = %f\n", poly3.dEval(1.0f));
float roots3[3];
bReal = poly3.getAllRoots(roots3);
if(bReal) {
printf("Roots: %f %f %f\n", roots3[0], roots3[1], roots3[2]);
} else {
printf("No Real roots!\n");
}
printf("\n\n");
printf("Foruth order polynomial test:\n");
float tmp4[] = {24, -50.0f, 35.0f, -10.0f, 1.0f};
pic::Polynomial poly4(tmp4, 5);
poly4.print();
auto poly4_2 = poly4.horner(3.0f, r);
printf("H: %s R: %f\n", poly4_2.toString().c_str(), r);;
printf("p(1.0f) = %f\n", poly4.eval(1.0f));
printf("dp(1.0f) = %f\n", poly4.dEval(1.0f));
float roots4[4];
bReal = poly4.getAllRoots(roots4);
if(bReal) {
printf("Roots: %f %f %f %f\n", roots4[0], roots4[1], roots4[2], roots4[3]);
} else {
printf("No Real roots!\n");
}
return 0;
}
