void BorderFilter::niepce(DImg& src, DImg& dest, const DColor& fg, int borderWidth, const DColor& bg, int lineWidth) { DImg tmp; solid(src, tmp, bg, lineWidth); solid(tmp, dest, fg, borderWidth); }
int not_solid_above(struct Player *p) { if((!solid(p->x, p->y - 1)) && (!solid(p->x + (p->w / 2), p->y - 1)) && (!solid(p->x + (p->w - 1), p->y - 1))) { return 1; } else { return 0; } }
void on_ground(struct Player *p) { if(solid(p->x, p->y + p->h) || solid(p->x + (p->w / 2), p->y + p->h) || solid(p->x + p->w - 1, p->y + p->h)) { p->on_ground = 1; } else { p->on_ground = 0; } }
void BorderFilter::pattern(DImg& src, DImg& dest, int borderWidth, const DColor& firstColor, const DColor& secondColor, int firstWidth, int secondWidth) { // Original image with the first solid border around. DImg tmp; solid(src, tmp, firstColor, firstWidth); // Border tiled image using pattern with second solid border around. int width, height; if (d->settings.orgWidth > d->settings.orgHeight) { height = tmp.height() + borderWidth * 2; width = (int)(height * d->orgRatio); } else { width = tmp.width() + borderWidth * 2; height = (int)(width / d->orgRatio); } DImg tmp2(width, height, tmp.sixteenBit(), tmp.hasAlpha()); qCDebug(DIGIKAM_DIMG_LOG) << "Border File:" << d->settings.borderPath; DImg border(d->settings.borderPath); if (border.isNull()) { return; } border.convertToDepthOfImage(&tmp2); for (int x = 0 ; x < width ; x += border.width()) { for (int y = 0 ; y < height ; y += border.height()) { tmp2.bitBltImage(&border, x, y); } } solid(tmp2, dest, secondColor, secondWidth); // Merge both images to one. if (d->settings.orgWidth > d->settings.orgHeight) { dest.bitBltImage(&tmp, (dest.width() - tmp.width()) / 2, borderWidth); } else { dest.bitBltImage(&tmp, borderWidth, (dest.height() - tmp.height()) / 2); } }
BOOL ExtTabControl::OnEraseBkgnd(CDC *pDC) { // REVIEW: this is a bit of a hack. The tab control uses its font to resize itself. // However, we use prof-uis paint manager's font to draw. This font can change (and be deleted) // when system settings change. But we don't know when to update it. So do it here. SetFont(&g_PaintManager->m_FontBoldBC); CRect rClient, rTab, rTotalTab, rBkgnd, rEdge; int nTab, nTabHeight = 0; __super::OnEraseBkgnd(pDC); // calc total tab width GetClientRect(rClient); nTab = GetItemCount(); rTotalTab.SetRectEmpty(); while (nTab--) { GetItemRect(nTab, rTab); rTotalTab.UnionRect(rTab, rTotalTab); } nTabHeight = rTotalTab.Height(); // add a bit rTotalTab.InflateRect(2, 3); rEdge = rTotalTab; // then if background color is set, paint the visible background // area of the tabs in the bkgnd color // note: the mfc code for drawing the tabs makes all sorts of assumptions // about the background color of the tab control being the same as the page // color - in some places the background color shows thru' the pages!! // so we must only paint the background color where we need to, which is that // portion of the tab area not excluded by the tabs themselves //CBrush *pBrush = &g_PaintManager->m_brushLighterDefault; CBrush solid(g_PaintManager->GetColor(COLOR_3DFACE)); CBrush *pBrush = &solid; // full width of tab ctrl above top of tabs rBkgnd = rClient; rBkgnd.bottom = rTotalTab.top + 3; pDC->FillRect(&rBkgnd, pBrush); // width of tab ctrl visible bkgnd including bottom pixel of tabs to left of tabs rBkgnd = rClient; rBkgnd.right = 2; rBkgnd.bottom = rBkgnd.top + (nTabHeight + 2); pDC->FillRect(&rBkgnd, pBrush); // to right of tabs rBkgnd = rClient; rBkgnd.left += rTotalTab.Width() - 2; rBkgnd.bottom = rBkgnd.top + (nTabHeight + 2); pDC->FillRect(&rBkgnd, pBrush); return TRUE; }
virtual void on_ctrl_change() { if(m_benchmark.status()) { int i; on_draw(); update_window(); scanline_rasterizer ras; pixfmt pixf(rbuf_window()); base_renderer rb(pixf); solid_renderer solid(rb); draft_renderer draft(rb); char buf[256]; if(m_draft.status()) { start_timer(); for(i = 0; i < 10; i++) { draw_scene(ras, solid, draft); } sprintf(buf, "%3.3f milliseconds", elapsed_time()); } else { double times[5]; for(m_draw = 0; m_draw < 4; m_draw++) { start_timer(); for(i = 0; i < 10; i++) { draw_scene(ras, solid, draft); } times[m_draw] = elapsed_time(); } m_draw = 3; times[4] = times[3]; times[3] -= times[2]; times[2] -= times[1]; times[1] -= times[0]; FILE* fd = fopen(full_file_name("benchmark"), "a"); fprintf(fd, "%10.3f %10.3f %10.3f %10.3f %10.3f\n", times[0], times[1], times[2], times[3], times[4]); fclose(fd); sprintf(buf, " pipeline add_path sort render total\n" "%10.3f %10.3f %10.3f %10.3f %10.3f", times[0], times[1], times[2], times[3], times[4]); } message(buf); m_benchmark.status(false); force_redraw(); } }
void DrawDownloadsOverlay(UIContext &ctx) { // Thin bar at the top of the screen like Chrome. std::vector<float> progress = g_DownloadManager.GetCurrentProgress(); if (progress.empty()) { return; } static const uint32_t colors[4] = { 0xFFFFFFFF, 0xFFCCCCCC, 0xFFAAAAAA, 0xFF777777, }; ctx.Begin(); int h = 5; for (int i = 0; i < progress.size(); i++) { float barWidth = 10 + (dp_xres - 10) * progress[i]; Bounds bounds(0, h * i, barWidth, h); UI::Drawable solid(colors[i & 3]); ctx.FillRect(solid, bounds); } ctx.End(); ctx.Flush(); }
/* >>>>>>>>>> EXA12_1 <<<<<<<<<< */ void exa12_1 (void) { int n = 50 ,i, j; static int ixp[4] = {200, 1999, 1999, 200}, iyp[4] = {2600, 2600, 801, 801}; double fpi = 3.1415927 / 180., step, x, y; step = 360. / (n - 1); for (i = 0; i < n; i++) { x = i * step; for (j = 0; j < n; j++) { y = j * step; zmat[i][j] = (float) (2 * sin (x * fpi) * sin (y * fpi)); } } setpag ("da4p"); disini (); pagera (); hwfont (); axspos (200, 2600); axslen (1800, 1800); name ("X-axis", "x"); name ("Y-axis", "y"); name ("Z-axis", "z"); titlin ("Surface Plot (SURMAT)", 2); titlin ("F(X,Y) = 2*SIN(X)*SIN(Y)", 4); graf3d (0.f, 360.f, 0.f, 90.f, 0.f, 360.f, 0.f, 90.f, -3.f, 3.f, -3.f, 1.f); height (50); title (); shlsur (); color ("green"); surmat ((float *) zmat, n, n, 1, 1); color ("fore"); grfini (-1.f, -1.f, -1.f, 1.f, -1.f, -1.f, 1.f, 1.f, -1.f); nograf (); graf (0.f, 360.f, 0.f, 90.f, 0.f, 360.f, 0.f, 90.f); dashl (); grid (1,1); grffin (); grfini (-1.f, -1.f, -1.f, -1.f, 1.f, -1.f, -1.f, 1.f, 1.f); graf (0.f, 360.f, 0.f, 90.f, -3.f, 3.f, -3.f, 1.f); grid (1, 1); grffin (); grfini (-1.f, 1.f, -1.f, 1.f, 1.f, -1.f, 1.f, 1.f, 1.f); shdpat (7L); solid (); areaf (ixp, iyp, 4); grffin (); disfin (); }
void PushButton::dragEnterEvent(QDragEnterEvent *e) { if (*(button) == Qt::LeftButton) { emit solid(); } else { emit dot(); } }
animation filler::bfs::fillSolid( PNG & img, int x, int y, RGBAPixel fillColor, int tolerance, int frameFreq ) { /** * @todo Your code here! You should replace the following line with a * correct call to fill with the correct colorPicker parameter. */ solidColorPicker solid(fillColor); return filler::fill<Queue>(img, x, y, solid, tolerance, frameFreq); }
point entity::midpoint() const { if(solid()) { const rect r = solid_rect(); return point(r.x() + r.w()/2, r.y() + r.h()/2); } const frame& f = current_frame(); return point(x() + f.width()/2, y() + f.height()/2); }
void check_against_map(struct Player *p) { int i; /* move down / fall */ if(p->vy > 0) { for(i = 0; i < p->vy; i++) { on_ground(p); if(!p->on_ground) { p->y += 1; } else { break; } } } /* jump */ if(p->on_ground) { if(p->vy < 0) { for(i = 0; i > p->vy; i--) { if(not_solid_above(p)) { p->y -= 1; } else { /* reset upward movement to prevent jumping if player hits above block and then moves left/right */ p->vy = 0; } } } } /* move right */ if(p->vx > 0) { for(i = 0; i < p->vx; i++) { if((!solid(p->x + p->w, p->y)) && (!solid(p->x + p->w, p->y + p->h/2 - 1)) && (!solid(p->x + p->w, p->y + p->h - 1))) { p->x += 1; } } } /* move left */ if(p->vx < 0) { for(i = 0; i > p->vx; i--) { if((!solid(p->x - 1, p->y)) && !solid(p->x - 1, p->y + p->h/2 - 1) && !solid(p->x - 1, p->y + p->h - 1)) { p->x -= 1; } } } }
//------------------------------------------------------------------------ virtual void on_draw() { scanline_rasterizer ras; pixfmt pixf(rbuf_window()); base_renderer rb(pixf); solid_renderer solid(rb); draft_renderer draft(rb); rb.clear(agg::rgba(1, 1, 1)); draw_scene(ras, solid, draft); ras.filling_rule(agg::fill_non_zero); agg::render_ctrl(ras, m_sl, rb, m_type); agg::render_ctrl(ras, m_sl, rb, m_width); agg::render_ctrl(ras, m_sl, rb, m_benchmark); agg::render_ctrl(ras, m_sl, rb, m_draw_nodes); agg::render_ctrl(ras, m_sl, rb, m_draw_edges); agg::render_ctrl(ras, m_sl, rb, m_draft); agg::render_ctrl(ras, m_sl, rb, m_translucent); }
void ResultsControlWidget::paint ( base_renderer& base ) { scanline_rasterizer ras; solid_renderer solid( base ); loadCaseText.start_point( ctrlLeft, 13 ); ras.add_path( textPoly ); solid.color( agg::rgba( 0, 0, 0 ) ); agg::render_scanlines( ras, scanline, solid ); ras.filling_rule( agg::fill_non_zero ); if ( ! deformAllowed ) { deformSlider.pointer_color( agg::rgba( 1, 1, 1, 0 ) ); deformSlider.num_steps( 0 ); deformSlider.range( 1, 1 ); deformSlider.value( 1 ); deformSlider.label(""); deformCheckBox.active_color( agg::rgba( 0, 0, 0, 0.4 ) ); deformCheckBox.inactive_color( agg::rgba( 0, 0, 0, 0.4 ) ); deformCheckBox.text_color( agg::rgba( 0, 0, 0, 0.4 ) ); deformCheckBox.status( deformCbState ); } else { deformSlider.num_steps( 19 ); deformSlider.range( 1, 20 ); deformSlider.label( "Deform scale %2.0f:1" ); deformSlider.pointer_color( agg::rgba( 45, 165, 195, 0.5 ) ); deformCheckBox.active_color( agg::rgba( 0, 0, 0 ) ); deformCheckBox.inactive_color( agg::rgba( 0, 0, 0 ) ); deformCheckBox.text_color( agg::rgba( 0, 0, 0 ) ); } agg::render_ctrl( ras, scanline, solid, deformSlider ); agg::render_ctrl( ras, scanline, solid, scaleSlider ); agg::render_ctrl( ras, scanline, solid, numberCheckBox ); agg::render_ctrl( ras, scanline, solid, deformCheckBox ); }
/* place block if there is enough room */ void place_block(int x, int y, struct Player *p) { int cam_x = x + map.min_x; int cam_y = y + map.min_y; int dx = cam_x/map.blocksize; int dy = cam_y/map.blocksize; int mass = ((p->selected == WATER5) || (p->selected == OIL)) ? MAX_MASS : 0; if((dx < map.w) && (dy < map.h) && not_player_position(dx, dy, p) ) { /* not solid at new block position, dirt, grass or rock selected & horizontal or vertical adjacent block exists (never place floating blocks) */ if(!solid(cam_x, cam_y) && (solid(cam_x + map.blocksize, cam_y) || solid(cam_x - map.blocksize, cam_y) || solid(cam_x, cam_y + map.blocksize) || solid(cam_x, cam_y - map.blocksize))) { if((p->selected == DIRT) || (p->selected == GRASS) || (p->selected == ROCK)) { map.tiles[dx][dy] = p->selected; map.new_water_mass[dx][dy] = mass; } } /* not solid at new block position and water, sand or oil selected */ if(!solid(cam_x, cam_y) && ((p->selected == WATER5) || (p->selected == SAND) || (p->selected == OIL))) { map.tiles[dx][dy] = p->selected; switch(p->selected) { case WATER5: map.new_water_mass[dx][dy] = mass; break; case OIL: map.new_oil_mass[dx][dy] = mass; break; default: break; } } } }
int main(int argc, char **argv) { sf::RenderWindow window(sf::VideoMode(600, 800), "The Floor Is Lava!"); //window.setVerticalSyncEnabled(true); window.setFramerateLimit(60); Camera camera(608, 800, 1); camera.MoveTowards(0.0f, -1.0f); std::unique_ptr<sf::Texture> lava(new sf::Texture); std::unique_ptr<sf::Texture> solid(new sf::Texture); std::unique_ptr<sf::Texture> player(new sf::Texture); sf::Font font; sf::Text score; if(!font.loadFromFile("Assets/Roboto-Regular.ttf")) { std::cerr << "Unable to load font!" << std::endl; } score.setString("0"); score.setFont(font); score.setCharacterSize(50); sf::View gui_view; gui_view.setSize(608, 800); gui_view.setCenter(300, 400); lava->loadFromFile("Assets/lava.png"); solid->loadFromFile("Assets/solid.png"); player->loadFromFile("Assets/player.png"); Tile lava_sprite(lava, Tile::LAVA); Tile solid_sprite(solid, Tile::SOLID); Player player_sprite(player, camera); //sf::Sprite lava_sprite; //sf::Sprite solid_sprite; //lava_sprite.setTexture(lava); //solid_sprite.setTexture(solid); //solid_sprite.move(sf::Vector2f(32, 0)); while (window.isOpen()) { sf::Event event; while (window.pollEvent(event)) { if (event.type == sf::Event::Closed) { window.close(); } if(event.type == sf::Event::KeyPressed) { if (player_sprite.IsAlive()){ switch (event.key.code) { case sf::Keyboard::Left: player_sprite.Move(-32.0f, 0.0f); break; case sf::Keyboard::Right: player_sprite.Move(32.0f, 0.0f); break; case sf::Keyboard::Up: player_sprite.Move(0.0f, -32.0f); break; case sf::Keyboard::Down: player_sprite.Move(0.0f, 32.0f); } } } } window.clear(sf::Color::Black); window.setView(camera.GetView()); if (player_sprite.IsAlive()) { camera.Update(); player_sprite.Update(); score.setString(std::to_string(player_sprite.GetScore())); } window.draw(lava_sprite.GetSprite()); window.draw(solid_sprite.GetSprite()); window.draw(player_sprite.GetPlayer()); window.setView(gui_view); window.draw(score); window.display(); } return 0; }
std::unique_ptr<PNS::SOLID> PNS_KICAD_IFACE::syncPad( D_PAD* aPad ) { LAYER_RANGE layers( 0, MAX_CU_LAYERS - 1 ); // ignore non-copper pads if( ( aPad->GetLayerSet() & LSET::AllCuMask()).none() ) return NULL; switch( aPad->GetAttribute() ) { case PAD_ATTRIB_STANDARD: break; case PAD_ATTRIB_SMD: case PAD_ATTRIB_HOLE_NOT_PLATED: case PAD_ATTRIB_CONN: { LSET lmsk = aPad->GetLayerSet(); bool is_copper = false; for( int i = 0; i < MAX_CU_LAYERS; i++ ) { if( lmsk[i] ) { is_copper = true; if( aPad->GetAttribute() != PAD_ATTRIB_HOLE_NOT_PLATED ) layers = LAYER_RANGE( i ); break; } } if( !is_copper ) return NULL; } break; default: wxLogTrace( "PNS", "unsupported pad type 0x%x", aPad->GetAttribute() ); return NULL; } std::unique_ptr< PNS::SOLID > solid( new PNS::SOLID ); solid->SetLayers( layers ); solid->SetNet( aPad->GetNetCode() ); solid->SetParent( aPad ); wxPoint wx_c = aPad->ShapePos(); wxSize wx_sz = aPad->GetSize(); wxPoint offset = aPad->GetOffset(); VECTOR2I c( wx_c.x, wx_c.y ); VECTOR2I sz( wx_sz.x, wx_sz.y ); RotatePoint( &offset, aPad->GetOrientation() ); solid->SetPos( VECTOR2I( c.x - offset.x, c.y - offset.y ) ); solid->SetOffset( VECTOR2I( offset.x, offset.y ) ); double orient = aPad->GetOrientation() / 10.0; if( aPad->GetShape() == PAD_SHAPE_CIRCLE ) { solid->SetShape( new SHAPE_CIRCLE( c, sz.x / 2 ) ); } else if( aPad->GetShape() == PAD_SHAPE_CUSTOM ) { SHAPE_POLY_SET outline; outline.Append( aPad->GetCustomShapeAsPolygon() ); aPad->CustomShapeAsPolygonToBoardPosition( &outline, wx_c, aPad->GetOrientation() ); SHAPE_CONVEX* shape = new SHAPE_CONVEX(); // We use the convex hull of the pad shape, because PnS knows // only convex shapes. std::vector<wxPoint> convex_hull; BuildConvexHull( convex_hull, outline ); for( unsigned ii = 0; ii < convex_hull.size(); ii++ ) shape->Append( convex_hull[ii] ); solid->SetShape( shape ); } else { if( orient == 0.0 || orient == 90.0 || orient == 180.0 || orient == 270.0 ) { if( orient == 90.0 || orient == 270.0 ) sz = VECTOR2I( sz.y, sz.x ); switch( aPad->GetShape() ) { case PAD_SHAPE_OVAL: if( sz.x == sz.y ) solid->SetShape( new SHAPE_CIRCLE( c, sz.x / 2 ) ); else { VECTOR2I delta; if( sz.x > sz.y ) delta = VECTOR2I( ( sz.x - sz.y ) / 2, 0 ); else delta = VECTOR2I( 0, ( sz.y - sz.x ) / 2 ); SHAPE_SEGMENT* shape = new SHAPE_SEGMENT( c - delta, c + delta, std::min( sz.x, sz.y ) ); solid->SetShape( shape ); } break; case PAD_SHAPE_RECT: solid->SetShape( new SHAPE_RECT( c - sz / 2, sz.x, sz.y ) ); break; case PAD_SHAPE_TRAPEZOID: { wxPoint coords[4]; aPad->BuildPadPolygon( coords, wxSize( 0, 0 ), aPad->GetOrientation() ); SHAPE_CONVEX* shape = new SHAPE_CONVEX(); for( int ii = 0; ii < 4; ii++ ) { shape->Append( wx_c + coords[ii] ); } solid->SetShape( shape ); break; } case PAD_SHAPE_ROUNDRECT: { SHAPE_POLY_SET outline; const int segmentToCircleCount = 64; aPad->BuildPadShapePolygon( outline, wxSize( 0, 0 ), segmentToCircleCount, 1.0 ); // TransformRoundRectToPolygon creates only one convex polygon SHAPE_LINE_CHAIN& poly = outline.Outline( 0 ); SHAPE_CONVEX* shape = new SHAPE_CONVEX(); for( int ii = 0; ii < poly.PointCount(); ++ii ) { shape->Append( wxPoint( poly.Point( ii ).x, poly.Point( ii ).y ) ); } solid->SetShape( shape ); } break; default: wxLogTrace( "PNS", "unsupported pad shape" ); return nullptr; } } else { switch( aPad->GetShape() ) { // PAD_SHAPE_CIRCLE and PAD_SHAPE_CUSTOM already handled above case PAD_SHAPE_OVAL: if( sz.x == sz.y ) solid->SetShape( new SHAPE_CIRCLE( c, sz.x / 2 ) ); else { wxPoint start; wxPoint end; wxPoint corner; SHAPE_CONVEX* shape = new SHAPE_CONVEX(); int w = aPad->BuildSegmentFromOvalShape( start, end, 0.0, wxSize( 0, 0 ) ); if( start.y == 0 ) corner = wxPoint( start.x, -( w / 2 ) ); else corner = wxPoint( w / 2, start.y ); RotatePoint( &start, aPad->GetOrientation() ); RotatePoint( &corner, aPad->GetOrientation() ); shape->Append( wx_c + corner ); for( int rot = 100; rot <= 1800; rot += 100 ) { wxPoint p( corner ); RotatePoint( &p, start, rot ); shape->Append( wx_c + p ); } if( end.y == 0 ) corner = wxPoint( end.x, w / 2 ); else corner = wxPoint( -( w / 2 ), end.y ); RotatePoint( &end, aPad->GetOrientation() ); RotatePoint( &corner, aPad->GetOrientation() ); shape->Append( wx_c + corner ); for( int rot = 100; rot <= 1800; rot += 100 ) { wxPoint p( corner ); RotatePoint( &p, end, rot ); shape->Append( wx_c + p ); } solid->SetShape( shape ); } break; case PAD_SHAPE_RECT: case PAD_SHAPE_TRAPEZOID: { wxPoint coords[4]; aPad->BuildPadPolygon( coords, wxSize( 0, 0 ), aPad->GetOrientation() ); SHAPE_CONVEX* shape = new SHAPE_CONVEX(); for( int ii = 0; ii < 4; ii++ ) { shape->Append( wx_c + coords[ii] ); } solid->SetShape( shape ); break; } case PAD_SHAPE_ROUNDRECT: { SHAPE_POLY_SET outline; const int segmentToCircleCount = 32; aPad->BuildPadShapePolygon( outline, wxSize( 0, 0 ), segmentToCircleCount, 1.0 ); // TransformRoundRectToPolygon creates only one convex polygon SHAPE_LINE_CHAIN& poly = outline.Outline( 0 ); SHAPE_CONVEX* shape = new SHAPE_CONVEX(); for( int ii = 0; ii < poly.PointCount(); ++ii ) { shape->Append( wxPoint( poly.Point( ii ).x, poly.Point( ii ).y ) ); } solid->SetShape( shape ); break; } default: wxLogTrace( "PNS", "unsupported pad shape" ); return nullptr; } } } return solid; }
TEST( SDCFsiTest, reuse ) { std::vector<int> nbIter; for ( int nbReuse = 0; nbReuse < 3; nbReuse++ ) { scalar r0 = 0.2; scalar a0 = M_PI * r0 * r0; scalar u0 = 0.1; scalar p0 = 0; scalar dt = 0.01; int N = 20; scalar L = 1; scalar T = 1; scalar dx = L / N; scalar rho = 1.225; scalar E = 490; scalar h = 1.0e-3; scalar cmk = std::sqrt( E * h / (2 * rho * r0) ); scalar c0 = std::sqrt( cmk * cmk - p0 / (2 * rho) ); scalar kappa = c0 / u0; bool parallel = false; int extrapolation = 0; scalar tol = 1.0e-5; int maxIter = 50; scalar initialRelaxation = 1.0e-3; int maxUsedIterations = 50; scalar singularityLimit = 1.0e-13; int reuseInformationStartingFromTimeIndex = 0; bool scaling = false; bool updateJacobian = false; scalar beta = 0.1; int minIter = 5; ASSERT_NEAR( kappa, 10, 1.0e-13 ); ASSERT_TRUE( dx > 0 ); std::shared_ptr<tubeflow::SDCTubeFlowFluidSolver> fluid( new tubeflow::SDCTubeFlowFluidSolver( a0, u0, p0, dt, cmk, N, L, T, rho ) ); std::shared_ptr<tubeflow::SDCTubeFlowSolidSolver> solid( new tubeflow::SDCTubeFlowSolidSolver( a0, cmk, p0, rho, L, N ) ); shared_ptr<RBFFunctionInterface> rbfFunction; shared_ptr<RBFInterpolation> rbfInterpolator; shared_ptr<RBFCoarsening> rbfInterpToCouplingMesh; shared_ptr<RBFCoarsening> rbfInterpToMesh; rbfFunction = shared_ptr<RBFFunctionInterface>( new TPSFunction() ); rbfInterpolator = shared_ptr<RBFInterpolation>( new RBFInterpolation( rbfFunction ) ); rbfInterpToCouplingMesh = shared_ptr<RBFCoarsening> ( new RBFCoarsening( rbfInterpolator ) ); rbfFunction = shared_ptr<RBFFunctionInterface>( new TPSFunction() ); rbfInterpolator = shared_ptr<RBFInterpolation>( new RBFInterpolation( rbfFunction ) ); rbfInterpToMesh = shared_ptr<RBFCoarsening> ( new RBFCoarsening( rbfInterpolator ) ); shared_ptr<MultiLevelSolver> fluidSolver( new MultiLevelSolver( fluid, fluid, rbfInterpToCouplingMesh, rbfInterpToMesh, 0, 0 ) ); rbfFunction = shared_ptr<RBFFunctionInterface>( new TPSFunction() ); rbfInterpolator = shared_ptr<RBFInterpolation>( new RBFInterpolation( rbfFunction ) ); rbfInterpToCouplingMesh = shared_ptr<RBFCoarsening> ( new RBFCoarsening( rbfInterpolator ) ); rbfFunction = shared_ptr<RBFFunctionInterface>( new TPSFunction() ); rbfInterpolator = shared_ptr<RBFInterpolation>( new RBFInterpolation( rbfFunction ) ); rbfInterpToMesh = shared_ptr<RBFCoarsening> ( new RBFCoarsening( rbfInterpolator ) ); shared_ptr<MultiLevelSolver> solidSolver( new MultiLevelSolver( solid, fluid, rbfInterpToCouplingMesh, rbfInterpToMesh, 1, 0 ) ); std::shared_ptr< std::list<std::shared_ptr<ConvergenceMeasure> > > convergenceMeasures; convergenceMeasures = std::shared_ptr<std::list<std::shared_ptr<ConvergenceMeasure> > >( new std::list<std::shared_ptr<ConvergenceMeasure> > ); convergenceMeasures->push_back( std::shared_ptr<ConvergenceMeasure>( new RelativeConvergenceMeasure( 0, false, tol ) ) ); convergenceMeasures->push_back( std::shared_ptr<ConvergenceMeasure>( new MinIterationConvergenceMeasure( 0, false, minIter ) ) ); shared_ptr<MultiLevelFsiSolver> fsi( new MultiLevelFsiSolver( fluidSolver, solidSolver, convergenceMeasures, parallel, extrapolation ) ); shared_ptr<PostProcessing> postProcessing( new AndersonPostProcessing( fsi, maxIter, initialRelaxation, maxUsedIterations, nbReuse, singularityLimit, reuseInformationStartingFromTimeIndex, scaling, beta, updateJacobian ) ); std::shared_ptr<sdc::SDCFsiSolverInterface> sdcFluidSolver = std::dynamic_pointer_cast<sdc::SDCFsiSolverInterface>( fluid ); std::shared_ptr<sdc::SDCFsiSolverInterface> sdcSolidSolver = std::dynamic_pointer_cast<sdc::SDCFsiSolverInterface>( solid ); assert( sdcFluidSolver ); assert( sdcSolidSolver ); std::shared_ptr<fsi::SDCFsiSolver> fsiSolver( new fsi::SDCFsiSolver( sdcFluidSolver, sdcSolidSolver, postProcessing, extrapolation ) ); int nbNodes = 3; std::shared_ptr<fsi::quadrature::IQuadrature<scalar> > quadrature; quadrature = std::shared_ptr<fsi::quadrature::IQuadrature<scalar> >( new fsi::quadrature::Uniform<scalar>( nbNodes ) ); std::shared_ptr<sdc::SDC> sdc( new sdc::SDC( fsiSolver, quadrature, 1.0e-10, nbNodes, nbNodes ) ); sdc->run(); nbIter.push_back( fsi->nbIter ); } int iprev; int index = 0; for ( int i : nbIter ) { std::cout << "nbIter = " << i << std::endl; if ( index > 0 ) ASSERT_LE( i, iprev ); iprev = i; index++; } }
void LocalImageLoaderPrivate::prepareImages() { QString file, filename, mime, stickerMime = qsl("image/webp"); int32 filesize = 0; QImage img; QByteArray data; PeerId peer; uint64 id, thumbId = 0; int32 duration = 0; QString thumbExt = "jpg"; ToPrepareMediaType type; bool animated = false; bool ctrlShiftEnter = false; MsgId replyTo = 0; { QMutexLocker lock(loader->toPrepareMutex()); ToPrepareMedias &list(loader->toPrepareMedias()); if (list.isEmpty()) return; file = list.front().file; img = list.front().img; data = list.front().data; peer = list.front().peer; id = list.front().id; type = list.front().type; duration = list.front().duration; ctrlShiftEnter = list.front().ctrlShiftEnter; replyTo = list.front().replyTo; } if (img.isNull()) { if (!file.isEmpty()) { QFileInfo info(file); if (type == ToPrepareAuto) { QString lower(file.toLower()); const QStringList &photoExtensions(cPhotoExtensions()); for (QStringList::const_iterator i = photoExtensions.cbegin(), e = photoExtensions.cend(); i != e; ++i) { if (lower.lastIndexOf(*i) == lower.size() - i->size()) { if (info.size() < MaxUploadPhotoSize) { type = ToPreparePhoto; break; } } } if (type == ToPrepareAuto && info.size() < MaxUploadDocumentSize) { type = ToPrepareDocument; } } if (type == ToPrepareDocument) { mime = mimeTypeForFile(info).name(); } if (type != ToPrepareAuto && info.size() < MaxUploadPhotoSize) { bool opaque = (mime != stickerMime); img = App::readImage(file, 0, opaque, &animated); } filename = info.fileName(); filesize = info.size(); } else if (!data.isEmpty()) { if (type != ToPrepareAudio) { img = App::readImage(data, 0, true, &animated); if (type == ToPrepareAuto) { if (!img.isNull() && data.size() < MaxUploadPhotoSize) { type = ToPreparePhoto; } else if (data.size() < MaxUploadDocumentSize) { type = ToPrepareDocument; } else { img = QImage(); } } } MimeType mimeType = mimeTypeForData(data); if (type == ToPrepareDocument || type == ToPrepareAudio) { mime = mimeType.name(); } if (mime == "image/jpeg") { filename = filedialogDefaultName(qsl("image"), qsl(".jpg"), QString(), true); } else if (type == ToPrepareAudio) { filename = filedialogDefaultName(qsl("audio"), qsl(".ogg"), QString(), true); mime = "audio/ogg"; } else { QString ext; QStringList patterns = mimeType.globPatterns(); if (!patterns.isEmpty()) { ext = patterns.front().replace('*', QString()); } filename = filedialogDefaultName((type == ToPrepareAudio) ? qsl("audio") : qsl("doc"), ext, QString(), true); } filesize = data.size(); } } else { if (type == ToPrepareDocument) { filename = filedialogDefaultName(qsl("image"), qsl(".png"), QString(), true); mime = mimeTypeForName("image/png").name(); data = QByteArray(); { QBuffer b(&data); img.save(&b, "PNG"); } filesize = data.size(); } else { if (img.hasAlphaChannel()) { QImage solid(img.width(), img.height(), QImage::Format_ARGB32_Premultiplied); solid.fill(st::white->c); { QPainter(&solid).drawImage(0, 0, img); } img = solid; } type = ToPreparePhoto; filename = qsl("Untitled.jpg"); filesize = 0; } } if ((img.isNull() && ((type != ToPrepareDocument && type != ToPrepareAudio) || !filesize)) || type == ToPrepareAuto || (img.isNull() && file.isEmpty() && data.isEmpty())) { // if could not decide what type { QMutexLocker lock(loader->toPrepareMutex()); ToPrepareMedias &list(loader->toPrepareMedias()); list.pop_front(); } QTimer::singleShot(1, this, SLOT(prepareImages())); emit imageFailed(id); } else { PreparedPhotoThumbs photoThumbs; QVector<MTPPhotoSize> photoSizes; QVector<MTPDocumentAttribute> attributes(1, MTP_documentAttributeFilename(MTP_string(filename))); MTPPhotoSize thumb(MTP_photoSizeEmpty(MTP_string(""))); MTPPhoto photo(MTP_photoEmpty(MTP_long(0))); MTPDocument document(MTP_documentEmpty(MTP_long(0))); MTPAudio audio(MTP_audioEmpty(MTP_long(0))); QByteArray jpeg; if (type == ToPreparePhoto) { int32 w = img.width(), h = img.height(); QPixmap thumb = (w > 100 || h > 100) ? QPixmap::fromImage(img.scaled(100, 100, Qt::KeepAspectRatio, Qt::SmoothTransformation), Qt::ColorOnly) : QPixmap::fromImage(img); photoThumbs.insert('s', thumb); photoSizes.push_back(MTP_photoSize(MTP_string("s"), MTP_fileLocationUnavailable(MTP_long(0), MTP_int(0), MTP_long(0)), MTP_int(thumb.width()), MTP_int(thumb.height()), MTP_int(0))); QPixmap medium = (w > 320 || h > 320) ? QPixmap::fromImage(img.scaled(320, 320, Qt::KeepAspectRatio, Qt::SmoothTransformation), Qt::ColorOnly) : QPixmap::fromImage(img); photoThumbs.insert('m', medium); photoSizes.push_back(MTP_photoSize(MTP_string("m"), MTP_fileLocationUnavailable(MTP_long(0), MTP_int(0), MTP_long(0)), MTP_int(medium.width()), MTP_int(medium.height()), MTP_int(0))); QPixmap full = (w > 1280 || h > 1280) ? QPixmap::fromImage(img.scaled(1280, 1280, Qt::KeepAspectRatio, Qt::SmoothTransformation), Qt::ColorOnly) : QPixmap::fromImage(img); photoThumbs.insert('y', full); photoSizes.push_back(MTP_photoSize(MTP_string("y"), MTP_fileLocationUnavailable(MTP_long(0), MTP_int(0), MTP_long(0)), MTP_int(full.width()), MTP_int(full.height()), MTP_int(0))); { QBuffer jpegBuffer(&jpeg); full.save(&jpegBuffer, "JPG", 77); } if (!filesize) filesize = jpeg.size(); photo = MTP_photo(MTP_long(id), MTP_long(0), MTP_int(user), MTP_int(unixtime()), MTP_geoPointEmpty(), MTP_vector<MTPPhotoSize>(photoSizes)); thumbId = id; } else if ((type == ToPrepareVideo || type == ToPrepareDocument) && !img.isNull()) { int32 w = img.width(), h = img.height(); QByteArray thumbFormat = "JPG"; int32 thumbQuality = 87; if (animated) { attributes.push_back(MTP_documentAttributeAnimated()); } else if (mime == stickerMime && w > 0 && h > 0 && w <= StickerMaxSize && h <= StickerMaxSize && filesize < StickerInMemory) { attributes.push_back(MTP_documentAttributeSticker(MTP_string(""), MTP_inputStickerSetEmpty())); thumbFormat = "webp"; thumbExt = qsl("webp"); } attributes.push_back(MTP_documentAttributeImageSize(MTP_int(w), MTP_int(h))); if (w < 20 * h && h < 20 * w) { QPixmap full = (w > 90 || h > 90) ? QPixmap::fromImage(img.scaled(90, 90, Qt::KeepAspectRatio, Qt::SmoothTransformation), Qt::ColorOnly) : QPixmap::fromImage(img, Qt::ColorOnly); { QBuffer jpegBuffer(&jpeg); full.save(&jpegBuffer, thumbFormat, thumbQuality); } photoThumbs.insert('0', full); thumb = MTP_photoSize(MTP_string(""), MTP_fileLocationUnavailable(MTP_long(0), MTP_int(0), MTP_long(0)), MTP_int(full.width()), MTP_int(full.height()), MTP_int(0)); thumbId = MTP::nonce<uint64>(); } } if (type == ToPrepareDocument) { document = MTP_document(MTP_long(id), MTP_long(0), MTP_int(unixtime()), MTP_string(mime), MTP_int(filesize), thumb, MTP_int(MTP::maindc()), MTP_vector<MTPDocumentAttribute>(attributes)); } else if (type == ToPrepareAudio) { audio = MTP_audio(MTP_long(id), MTP_long(0), MTP_int(user), MTP_int(unixtime()), MTP_int(duration), MTP_string(mime), MTP_int(filesize), MTP_int(MTP::maindc())); } { QMutexLocker lock(loader->readyMutex()); loader->readyList().push_back(ReadyLocalMedia(type, file, filename, filesize, data, id, thumbId, thumbExt, peer, photo, audio, photoThumbs, document, jpeg, ctrlShiftEnter, replyTo)); } { QMutexLocker lock(loader->toPrepareMutex()); ToPrepareMedias &list(loader->toPrepareMedias()); list.pop_front(); } QTimer::singleShot(1, this, SLOT(prepareImages())); emit imageReady(); } }
void GltSkySphere::draw() const { if (!visible()) return; GLERROR GltViewport viewport(true); // // Setup perspective camera mode, // orthogonal doesn't really work... // glMatrixMode(GL_PROJECTION); glPushMatrix(); glLoadIdentity(); gluPerspective(_fov,double(viewport.width())/double(viewport.height()), 0.1, 200.0); // // Twiddle the current modelview matrix // to cancel out translation and scale. // glMatrixMode(GL_MODELVIEW); glPushMatrix(); Matrix matrix(GL_MODELVIEW_MATRIX); // No translation matrix[12] = 0.0; matrix[13] = 0.0; matrix[14] = 0.0; // No scale const real sf = sqrt( SQ(matrix[0]) + SQ(matrix[1]) + SQ(matrix[2]) ); matrix *= matrixScale(1.0/sf); // matrix.glLoadMatrix(); transformation().glMultMatrix(); // // // GLERROR glPushAttrib(GL_ENABLE_BIT|GL_POLYGON_BIT|GL_LIGHTING_BIT); glDisable(GL_DEPTH_TEST); glDisable(GL_LIGHTING); glDisable(GL_TEXTURE_2D); glEnable(GL_CULL_FACE); if (solid()) { glEnable(GL_BLEND); glBlendFunc(GL_SRC_ALPHA,GL_ONE_MINUS_SRC_ALPHA); glPolygonMode(GL_FRONT_AND_BACK,GL_FILL); glShadeModel(GL_SMOOTH); } else { glDisable(GL_BLEND); glPolygonMode(GL_FRONT_AND_BACK,GL_LINE); glShadeModel(GL_FLAT); } // drawSphere(_map,_slices); // glPopAttrib(); GLERROR glPopMatrix(); glMatrixMode(GL_PROJECTION); glPopMatrix(); glMatrixMode(GL_MODELVIEW); GLERROR }
TEST( SDIRKFsiSolidTest, linearized ) { scalar r0 = 3.0e-3; scalar h = 3.0e-4; scalar L = 0.126; scalar rho_s = 1000; scalar E0 = 4.0e5; scalar G = 4.0e5; scalar nu = 0.5; scalar a0 = M_PI * r0 * r0; scalar u0 = 0.26; scalar p0 = 0; int N = 5; scalar T = 1; scalar rho_f = 1060; scalar E = 490; scalar cmk = std::sqrt( E * h / (2 * rho_f * r0) ); bool parallel = false; int extrapolation = 0; scalar tol = 1.0e-8; int maxIter = 50; scalar initialRelaxation = 1.0e-3; int maxUsedIterations = 50; int nbReuse = 0; scalar singularityLimit = 1.0e-13; int reuseInformationStartingFromTimeIndex = 0; bool scaling = false; scalar beta = 0.01; bool updateJacobian = false; int minIter = 5; int nbComputations = 3; std::deque<std::shared_ptr<tubeflow::SDCTubeFlowFluidSolver> > fluidSolvers; std::deque<std::shared_ptr<tubeflow::SDCTubeFlowLinearizedSolidSolver> > solidSolvers; std::deque<int> nbTimeStepsList; for ( int iComputation = 0; iComputation < nbComputations; iComputation++ ) { int nbTimeSteps = 120 * std::pow( 2, iComputation ); std::cout << "nbTimeSteps = " << nbTimeSteps << std::endl; scalar dt = T / nbTimeSteps; std::shared_ptr<tubeflow::SDCTubeFlowFluidSolver> fluid( new tubeflow::SDCTubeFlowFluidSolver( a0, u0, p0, dt, cmk, N, L, T, rho_f ) ); std::shared_ptr<tubeflow::SDCTubeFlowLinearizedSolidSolver> solid( new tubeflow::SDCTubeFlowLinearizedSolidSolver( N, nu, rho_s, h, L, dt, G, E0, r0, T ) ); shared_ptr<RBFFunctionInterface> rbfFunction; shared_ptr<RBFInterpolation> rbfInterpolator; shared_ptr<RBFCoarsening> rbfInterpToCouplingMesh; shared_ptr<RBFCoarsening> rbfInterpToMesh; rbfFunction = shared_ptr<RBFFunctionInterface>( new TPSFunction() ); rbfInterpolator = shared_ptr<RBFInterpolation>( new RBFInterpolation( rbfFunction ) ); rbfInterpToCouplingMesh = shared_ptr<RBFCoarsening> ( new RBFCoarsening( rbfInterpolator ) ); rbfFunction = shared_ptr<RBFFunctionInterface>( new TPSFunction() ); rbfInterpolator = shared_ptr<RBFInterpolation>( new RBFInterpolation( rbfFunction ) ); rbfInterpToMesh = shared_ptr<RBFCoarsening> ( new RBFCoarsening( rbfInterpolator ) ); shared_ptr<MultiLevelSolver> fluidSolver( new MultiLevelSolver( fluid, fluid, rbfInterpToCouplingMesh, rbfInterpToMesh, 0, 0 ) ); rbfFunction = shared_ptr<RBFFunctionInterface>( new TPSFunction() ); rbfInterpolator = shared_ptr<RBFInterpolation>( new RBFInterpolation( rbfFunction ) ); rbfInterpToCouplingMesh = shared_ptr<RBFCoarsening> ( new RBFCoarsening( rbfInterpolator ) ); rbfFunction = shared_ptr<RBFFunctionInterface>( new TPSFunction() ); rbfInterpolator = shared_ptr<RBFInterpolation>( new RBFInterpolation( rbfFunction ) ); rbfInterpToMesh = shared_ptr<RBFCoarsening> ( new RBFCoarsening( rbfInterpolator ) ); shared_ptr<MultiLevelSolver> solidSolver( new MultiLevelSolver( solid, fluid, rbfInterpToCouplingMesh, rbfInterpToMesh, 1, 0 ) ); std::shared_ptr< std::list<std::shared_ptr<ConvergenceMeasure> > > convergenceMeasures; convergenceMeasures = std::shared_ptr<std::list<std::shared_ptr<ConvergenceMeasure> > >( new std::list<std::shared_ptr<ConvergenceMeasure> >() ); convergenceMeasures->push_back( std::shared_ptr<ConvergenceMeasure>( new RelativeConvergenceMeasure( 0, true, tol ) ) ); convergenceMeasures->push_back( std::shared_ptr<ConvergenceMeasure>( new MinIterationConvergenceMeasure( 0, false, minIter ) ) ); shared_ptr<MultiLevelFsiSolver> fsi( new MultiLevelFsiSolver( fluidSolver, solidSolver, convergenceMeasures, parallel, extrapolation ) ); shared_ptr<PostProcessing> postProcessing( new AndersonPostProcessing( fsi, maxIter, initialRelaxation, maxUsedIterations, nbReuse, singularityLimit, reuseInformationStartingFromTimeIndex, scaling, beta, updateJacobian ) ); std::shared_ptr<sdc::SDCFsiSolverInterface> sdcFluidSolver = std::dynamic_pointer_cast<sdc::SDCFsiSolverInterface>( fluid ); std::shared_ptr<sdc::SDCFsiSolverInterface> sdcSolidSolver = std::dynamic_pointer_cast<sdc::SDCFsiSolverInterface>( solid ); assert( sdcFluidSolver ); assert( sdcSolidSolver ); std::shared_ptr<fsi::SDCFsiSolver> fsiSolver( new fsi::SDCFsiSolver( sdcFluidSolver, sdcSolidSolver, postProcessing, extrapolation ) ); std::shared_ptr<sdc::AdaptiveTimeStepper> adaptiveTimeStepper( new sdc::AdaptiveTimeStepper( false ) ); std::string method = "ESDIRK53PR"; std::shared_ptr<sdc::ESDIRK> esdirk( new sdc::ESDIRK( fsiSolver, method, adaptiveTimeStepper ) ); esdirk->run(); fluidSolvers.push_back( fluid ); solidSolvers.push_back( solid ); nbTimeStepsList.push_back( nbTimeSteps ); } std::cout << "solid" << std::endl; for ( int i = 0; i < 2; i++ ) { fsi::vector ref; if ( i == 0 ) ref = solidSolvers.back()->r; else ref = solidSolvers.back()->u; std::deque<scalar> errors; for ( int iComputation = 0; iComputation < nbComputations - 1; iComputation++ ) { fsi::vector data; if ( i == 0 ) data = solidSolvers.at( iComputation )->r; else data = solidSolvers.at( iComputation )->u; scalar error = (ref - data).norm() / ref.norm(); errors.push_back( error ); } for ( int iComputation = 0; iComputation < nbComputations - 2; iComputation++ ) { scalar order = ( std::log10( errors.at( iComputation ) ) - std::log10( errors.at( iComputation + 1 ) ) ) / ( std::log10( nbTimeStepsList.at( iComputation + 1 ) ) - std::log10( nbTimeStepsList.at( iComputation ) ) ); std::cout << "order = " << order << std::endl; if ( i == 0 ) ASSERT_NEAR( order, 3, 0.1 ); } } std::cout << "fluid" << std::endl; for ( int i = 0; i < 3; i++ ) { fsi::vector ref; if ( i == 0 ) ref = fluidSolvers.back()->u; if ( i == 1 ) ref = fluidSolvers.back()->a; if ( i == 2 ) ref = fluidSolvers.back()->p; std::deque<scalar> errors; for ( int iComputation = 0; iComputation < nbComputations - 1; iComputation++ ) { fsi::vector data; if ( i == 0 ) data = fluidSolvers.at( iComputation )->u; if ( i == 1 ) data = fluidSolvers.at( iComputation )->a; if ( i == 2 ) data = fluidSolvers.at( iComputation )->p; scalar error = (ref - data).norm() / ref.norm(); errors.push_back( error ); } for ( int iComputation = 0; iComputation < nbComputations - 2; iComputation++ ) { scalar order = ( std::log10( errors.at( iComputation ) ) - std::log10( errors.at( iComputation + 1 ) ) ) / ( std::log10( nbTimeStepsList.at( iComputation + 1 ) ) - std::log10( nbTimeStepsList.at( iComputation ) ) ); std::cout << "order = " << order << std::endl; if ( i == 1 || i == 2 ) ASSERT_NEAR( order, 3, 0.1 ); } } }
int main(int argc, char **argv) { uint32_t timestamp; PixmapPtr dest = NULL; int fd, ret; fd = open("replay.txt", 0); if (fd < 0) { ERROR_MSG("could not open"); return -1; } RD_START("replay", "replay"); init(); while(1) { char *line = readline(fd); DEBUG_MSG("line: %s", line); if (strstr(line, "EXA: SOLID:") == line) { int x1, y1, x2, y2; uint32_t fill; sscanf(line, "EXA: SOLID: x1=%d\ty1=%d\tx2=%d\ty2=%d\tfill=%08x", &x1, &y1, &x2, &y2, &fill); DEBUG_MSG("GOT: SOLID: x1=%d\ty1=%d\tx2=%d\ty2=%d\tfill=%08x", x1, y1, x2, y2, fill); dest = get_pixmap(fd); solid(dest, x1, y1, x2, y2, fill); } else if (strstr(line, "EXA: COPY:") == line) { int srcX, srcY, dstX, dstY, width, height; PixmapPtr src; sscanf(line, "EXA: COPY: srcX=%d\tsrcY=%d\tdstX=%d\tdstY=%d\twidth=%d\theight=%d", &srcX, &srcY, &dstX, &dstY, &width, &height); DEBUG_MSG("GOT: COPY: srcX=%d\tsrcY=%d\tdstX=%d\tdstY=%d\twidth=%d\theight=%d", srcX, srcY, dstX, dstY, width, height); dest = get_pixmap(fd); src = get_pixmap(fd); copy(dest, src, srcX, srcY, dstX, dstY, width, height); } else if (strstr(line, "EXA: COMPOSITE:") == line) { ERROR_MSG("TODO"); end(); } else if (strstr(line, "EXA: WAIT:") == line) { DEBUG_MSG("wait, timestamp=%u", timestamp); wait(timestamp); } else if (strstr(line, "FLUSH:") == line) { flush(dest, ×tamp); DEBUG_MSG("flush, timestamp=%u", timestamp); } else { ERROR_MSG("unexpected line: %s", line); end(); } } return 0; }
void BorderFilter::filterImage() { d->setup(m_orgImage); switch (d->settings.borderType) { case BorderContainer::SolidBorder: if (d->settings.preserveAspectRatio) { solid(m_orgImage, m_destImage, d->solidColor, d->borderMainWidth); } else { solid2(m_orgImage, m_destImage, d->solidColor, d->settings.borderWidth1); } break; case BorderContainer::NiepceBorder: if (d->settings.preserveAspectRatio) niepce(m_orgImage, m_destImage, d->niepceBorderColor, d->borderMainWidth, d->niepceLineColor, d->border2ndWidth); else niepce2(m_orgImage, m_destImage, d->niepceBorderColor, d->settings.borderWidth1, d->niepceLineColor, d->settings.borderWidth4); break; case BorderContainer::BeveledBorder: if (d->settings.preserveAspectRatio) bevel(m_orgImage, m_destImage, d->bevelUpperLeftColor, d->bevelLowerRightColor, d->borderMainWidth); else bevel2(m_orgImage, m_destImage, d->bevelUpperLeftColor, d->bevelLowerRightColor, d->settings.borderWidth1); break; case BorderContainer::PineBorder: case BorderContainer::WoodBorder: case BorderContainer::PaperBorder: case BorderContainer::ParqueBorder: case BorderContainer::IceBorder: case BorderContainer::LeafBorder: case BorderContainer::MarbleBorder: case BorderContainer::RainBorder: case BorderContainer::CratersBorder: case BorderContainer::DriedBorder: case BorderContainer::PinkBorder: case BorderContainer::StoneBorder: case BorderContainer::ChalkBorder: case BorderContainer::GraniteBorder: case BorderContainer::RockBorder: case BorderContainer::WallBorder: if (d->settings.preserveAspectRatio) pattern(m_orgImage, m_destImage, d->borderMainWidth, d->decorativeFirstColor, d->decorativeSecondColor, d->border2ndWidth, d->border2ndWidth); else pattern2(m_orgImage, m_destImage, d->settings.borderWidth1, d->decorativeFirstColor, d->decorativeSecondColor, d->settings.borderWidth2, d->settings.borderWidth2); break; } }
bool entity::has_feet() const { return solid(); }
void FileLoadTask::process() { const QString stickerMime = qsl("image/webp"); _result = FileLoadResultPtr(new FileLoadResult(_id, _to, _originalText)); QString filename, filemime; qint64 filesize = 0; QByteArray filedata; uint64 thumbId = 0; QString thumbname = "thumb.jpg"; QByteArray thumbdata; bool animated = false, song = false, gif = false, voice = (_type == PrepareAudio); QImage fullimage = _image; if (!_filepath.isEmpty()) { QFileInfo info(_filepath); if (info.isDir()) { _result->filesize = -1; return; } filesize = info.size(); filemime = mimeTypeForFile(info).name(); filename = info.fileName(); if (filesize <= MaxUploadPhotoSize && !voice) { bool opaque = (filemime != stickerMime); fullimage = App::readImage(_filepath, 0, opaque, &animated); } } else if (!_content.isEmpty()) { filesize = _content.size(); if (voice) { filename = filedialogDefaultName(qsl("audio"), qsl(".ogg"), QString(), true); filemime = "audio/ogg"; } else { MimeType mimeType = mimeTypeForData(_content); filemime = mimeType.name(); if (filesize <= MaxUploadPhotoSize && !voice) { bool opaque = (filemime != stickerMime); fullimage = App::readImage(_content, 0, opaque, &animated); } if (filemime == "image/jpeg") { filename = filedialogDefaultName(qsl("image"), qsl(".jpg"), QString(), true); } else { QString ext; QStringList patterns = mimeType.globPatterns(); if (!patterns.isEmpty()) { ext = patterns.front().replace('*', QString()); } filename = filedialogDefaultName(qsl("file"), ext, QString(), true); } } } else if (!_image.isNull()) { _image = QImage(); filemime = mimeTypeForName("image/png").name(); filename = filedialogDefaultName(qsl("image"), qsl(".png"), QString(), true); { QBuffer buffer(&_content); fullimage.save(&buffer, "PNG"); } filesize = _content.size(); if (fullimage.hasAlphaChannel()) { QImage solid(fullimage.width(), fullimage.height(), QImage::Format_ARGB32_Premultiplied); solid.fill(st::white->c); { QPainter(&solid).drawImage(0, 0, fullimage); } fullimage = solid; } } _result->filesize = (int32)qMin(filesize, qint64(INT_MAX)); if (!filesize || filesize > MaxUploadDocumentSize) { return; } PreparedPhotoThumbs photoThumbs; QVector<MTPPhotoSize> photoSizes; QPixmap thumb; QVector<MTPDocumentAttribute> attributes(1, MTP_documentAttributeFilename(MTP_string(filename))); MTPPhotoSize thumbSize(MTP_photoSizeEmpty(MTP_string(""))); MTPPhoto photo(MTP_photoEmpty(MTP_long(0))); MTPDocument document(MTP_documentEmpty(MTP_long(0))); if (!voice) { if (filemime == qstr("audio/mp3") || filemime == qstr("audio/m4a") || filemime == qstr("audio/aac") || filemime == qstr("audio/ogg") || filemime == qstr("audio/flac") || filename.endsWith(qstr(".mp3"), Qt::CaseInsensitive) || filename.endsWith(qstr(".m4a"), Qt::CaseInsensitive) || filename.endsWith(qstr(".aac"), Qt::CaseInsensitive) || filename.endsWith(qstr(".ogg"), Qt::CaseInsensitive) || filename.endsWith(qstr(".flac"), Qt::CaseInsensitive)) { QImage cover; QByteArray coverBytes, coverFormat; MTPDocumentAttribute audioAttribute = audioReadSongAttributes(_filepath, _content, cover, coverBytes, coverFormat); if (audioAttribute.type() == mtpc_documentAttributeAudio) { attributes.push_back(audioAttribute); song = true; if (!cover.isNull()) { // cover to thumb int32 cw = cover.width(), ch = cover.height(); if (cw < 20 * ch && ch < 20 * cw) { QPixmap full = (cw > 90 || ch > 90) ? QPixmap::fromImage(cover.scaled(90, 90, Qt::KeepAspectRatio, Qt::SmoothTransformation), Qt::ColorOnly) : QPixmap::fromImage(cover, Qt::ColorOnly); { QByteArray thumbFormat = "JPG"; int32 thumbQuality = 87; QBuffer buffer(&thumbdata); full.save(&buffer, thumbFormat, thumbQuality); } thumb = full; thumbSize = MTP_photoSize(MTP_string(""), MTP_fileLocationUnavailable(MTP_long(0), MTP_int(0), MTP_long(0)), MTP_int(full.width()), MTP_int(full.height()), MTP_int(0)); thumbId = rand_value<uint64>(); } } } } if (filemime == qstr("video/mp4") || filename.endsWith(qstr(".mp4"), Qt::CaseInsensitive) || animated) { QImage cover; MTPDocumentAttribute animatedAttribute = clipReadAnimatedAttributes(_filepath, _content, cover); if (animatedAttribute.type() == mtpc_documentAttributeVideo) { int32 cw = cover.width(), ch = cover.height(); if (cw < 20 * ch && ch < 20 * cw) { attributes.push_back(MTP_documentAttributeAnimated()); attributes.push_back(animatedAttribute); gif = true; QPixmap full = (cw > 90 || ch > 90) ? QPixmap::fromImage(cover.scaled(90, 90, Qt::KeepAspectRatio, Qt::SmoothTransformation), Qt::ColorOnly) : QPixmap::fromImage(cover, Qt::ColorOnly); { QByteArray thumbFormat = "JPG"; int32 thumbQuality = 87; QBuffer buffer(&thumbdata); full.save(&buffer, thumbFormat, thumbQuality); } thumb = full; thumbSize = MTP_photoSize(MTP_string(""), MTP_fileLocationUnavailable(MTP_long(0), MTP_int(0), MTP_long(0)), MTP_int(full.width()), MTP_int(full.height()), MTP_int(0)); thumbId = rand_value<uint64>(); if (filename.endsWith(qstr(".mp4"), Qt::CaseInsensitive)) { filemime = qstr("video/mp4"); } } } } } if (!fullimage.isNull() && fullimage.width() > 0 && !song && !gif && !voice) { int32 w = fullimage.width(), h = fullimage.height(); attributes.push_back(MTP_documentAttributeImageSize(MTP_int(w), MTP_int(h))); if (w < 20 * h && h < 20 * w) { if (animated) { attributes.push_back(MTP_documentAttributeAnimated()); } else if (_type != PrepareDocument) { QPixmap thumb = (w > 100 || h > 100) ? QPixmap::fromImage(fullimage.scaled(100, 100, Qt::KeepAspectRatio, Qt::SmoothTransformation), Qt::ColorOnly) : QPixmap::fromImage(fullimage); photoThumbs.insert('s', thumb); photoSizes.push_back(MTP_photoSize(MTP_string("s"), MTP_fileLocationUnavailable(MTP_long(0), MTP_int(0), MTP_long(0)), MTP_int(thumb.width()), MTP_int(thumb.height()), MTP_int(0))); QPixmap medium = (w > 320 || h > 320) ? QPixmap::fromImage(fullimage.scaled(320, 320, Qt::KeepAspectRatio, Qt::SmoothTransformation), Qt::ColorOnly) : QPixmap::fromImage(fullimage); photoThumbs.insert('m', medium); photoSizes.push_back(MTP_photoSize(MTP_string("m"), MTP_fileLocationUnavailable(MTP_long(0), MTP_int(0), MTP_long(0)), MTP_int(medium.width()), MTP_int(medium.height()), MTP_int(0))); QPixmap full = (w > 1280 || h > 1280) ? QPixmap::fromImage(fullimage.scaled(1280, 1280, Qt::KeepAspectRatio, Qt::SmoothTransformation), Qt::ColorOnly) : QPixmap::fromImage(fullimage); photoThumbs.insert('y', full); photoSizes.push_back(MTP_photoSize(MTP_string("y"), MTP_fileLocationUnavailable(MTP_long(0), MTP_int(0), MTP_long(0)), MTP_int(full.width()), MTP_int(full.height()), MTP_int(0))); { QBuffer buffer(&filedata); full.save(&buffer, "JPG", 77); } photo = MTP_photo(MTP_long(_id), MTP_long(0), MTP_int(unixtime()), MTP_vector<MTPPhotoSize>(photoSizes)); } QByteArray thumbFormat = "JPG"; int32 thumbQuality = 87; if (!animated && filemime == stickerMime && w > 0 && h > 0 && w <= StickerMaxSize && h <= StickerMaxSize && filesize < StickerInMemory) { attributes.push_back(MTP_documentAttributeSticker(MTP_string(""), MTP_inputStickerSetEmpty())); thumbFormat = "webp"; thumbname = qsl("thumb.webp"); } QPixmap full = (w > 90 || h > 90) ? QPixmap::fromImage(fullimage.scaled(90, 90, Qt::KeepAspectRatio, Qt::SmoothTransformation), Qt::ColorOnly) : QPixmap::fromImage(fullimage, Qt::ColorOnly); { QBuffer buffer(&thumbdata); full.save(&buffer, thumbFormat, thumbQuality); } thumb = full; thumbSize = MTP_photoSize(MTP_string(""), MTP_fileLocationUnavailable(MTP_long(0), MTP_int(0), MTP_long(0)), MTP_int(full.width()), MTP_int(full.height()), MTP_int(0)); thumbId = rand_value<uint64>(); } } if (voice) { attributes[0] = MTP_documentAttributeAudio(MTP_flags(MTPDdocumentAttributeAudio::Flag::f_voice | MTPDdocumentAttributeAudio::Flag::f_waveform), MTP_int(_duration), MTPstring(), MTPstring(), MTP_bytes(documentWaveformEncode5bit(_waveform))); attributes.resize(1); document = MTP_document(MTP_long(_id), MTP_long(0), MTP_int(unixtime()), MTP_string(filemime), MTP_int(filesize), thumbSize, MTP_int(MTP::maindc()), MTP_vector<MTPDocumentAttribute>(attributes)); } else { document = MTP_document(MTP_long(_id), MTP_long(0), MTP_int(unixtime()), MTP_string(filemime), MTP_int(filesize), thumbSize, MTP_int(MTP::maindc()), MTP_vector<MTPDocumentAttribute>(attributes)); if (photo.type() == mtpc_photoEmpty) { _type = PrepareDocument; } } _result->type = _type; _result->filepath = _filepath; _result->content = _content; _result->filename = filename; _result->filemime = filemime; _result->setFileData(filedata); _result->thumbId = thumbId; _result->thumbname = thumbname; _result->setThumbData(thumbdata); _result->thumb = thumb; _result->photo = photo; _result->document = document; _result->photoThumbs = photoThumbs; }
void thermalBaffle1DFvPatchScalarField<solidType>::updateCoeffs() { if (updated()) { return; } // Since we're inside initEvaluate/evaluate there might be processor // comms underway. Change the tag we use. int oldTag = UPstream::msgType(); UPstream::msgType() = oldTag+1; const mapDistribute& mapDist = this->mappedPatchBase::map(); const label patchi = patch().index(); const label nbrPatchi = samplePolyPatch().index(); if (baffleActivated_) { const fvPatch& nbrPatch = patch().boundaryMesh()[nbrPatchi]; const compressible::turbulenceModel& turbModel = db().template lookupObject<compressible::turbulenceModel> ( "turbulenceModel" ); // local properties const scalarField kappaw(turbModel.kappaEff(patchi)); const fvPatchScalarField& Tp = patch().template lookupPatchField<volScalarField, scalar>(TName_); scalarField Qr(Tp.size(), 0.0); if (QrName_ != "none") { Qr = patch().template lookupPatchField<volScalarField, scalar> (QrName_); Qr = QrRelaxation_*Qr + (1.0 - QrRelaxation_)*QrPrevious_; QrPrevious_ = Qr; } tmp<scalarField> Ti = patchInternalField(); scalarField myKDelta(patch().deltaCoeffs()*kappaw); // nrb properties scalarField nbrTp = turbModel.thermo().T().boundaryField()[nbrPatchi]; mapDist.distribute(nbrTp); // solid properties scalarField kappas(patch().size(), 0.0); forAll(kappas, i) { kappas[i] = solid().kappa(0.0, (Tp[i] + nbrTp[i])/2.0); } const scalarField KDeltaSolid(kappas/baffleThickness()); const scalarField alpha(KDeltaSolid - Qr/Tp); valueFraction() = alpha/(alpha + myKDelta); refValue() = (KDeltaSolid*nbrTp + Qs()/2.0)/alpha; if (debug) { scalar Q = gAverage(kappaw*snGrad()); Info<< patch().boundaryMesh().mesh().name() << ':' << patch().name() << ':' << this->dimensionedInternalField().name() << " <- " << nbrPatch.name() << ':' << this->dimensionedInternalField().name() << " :" << " heat[W]:" << Q << " walltemperature " << " min:" << gMin(*this) << " max:" << gMax(*this) << " avg:" << gAverage(*this) << endl; } }
TEST( SDCFsiTest, order ) { int N = 5; scalar r0 = 0.2; scalar a0 = M_PI * r0 * r0; scalar u0 = 0.1; scalar p0 = 0; scalar L = 1; scalar T = 1; scalar dx = L / N; scalar rho = 1.225; scalar E = 490; scalar h = 1.0e-3; scalar cmk = std::sqrt( E * h / (2 * rho * r0) ); scalar c0 = std::sqrt( cmk * cmk - p0 / (2 * rho) ); scalar kappa = c0 / u0; bool parallel = false; int extrapolation = 0; scalar tol = 1.0e-5; int maxIter = 20; scalar initialRelaxation = 1.0e-3; int maxUsedIterations = 50; int nbReuse = 0; scalar singularityLimit = 1.0e-13; int reuseInformationStartingFromTimeIndex = 0; bool scaling = false; scalar beta = 0.01; bool updateJacobian = false; int minIter = 5; ASSERT_NEAR( kappa, 10, 1.0e-13 ); ASSERT_TRUE( dx > 0 ); int nbComputations = 5; std::deque<std::shared_ptr<tubeflow::SDCTubeFlowFluidSolver> > fluidSolvers; std::deque<int> nbTimeStepsList; for ( int iComputation = 0; iComputation < nbComputations; iComputation++ ) { int nbTimeSteps = 4 * std::pow( 2, iComputation ); std::cout << "nbTimeSteps = " << nbTimeSteps << std::endl; scalar dt = T / nbTimeSteps; std::shared_ptr<tubeflow::SDCTubeFlowFluidSolver> fluid( new tubeflow::SDCTubeFlowFluidSolver( a0, u0, p0, dt, cmk, N, L, T, rho ) ); std::shared_ptr<tubeflow::SDCTubeFlowSolidSolver> solid( new tubeflow::SDCTubeFlowSolidSolver( a0, cmk, p0, rho, L, N ) ); shared_ptr<RBFFunctionInterface> rbfFunction; shared_ptr<RBFInterpolation> rbfInterpolator; shared_ptr<RBFCoarsening> rbfInterpToCouplingMesh; shared_ptr<RBFCoarsening> rbfInterpToMesh; rbfFunction = shared_ptr<RBFFunctionInterface>( new TPSFunction() ); rbfInterpolator = shared_ptr<RBFInterpolation>( new RBFInterpolation( rbfFunction ) ); rbfInterpToCouplingMesh = shared_ptr<RBFCoarsening> ( new RBFCoarsening( rbfInterpolator ) ); rbfFunction = shared_ptr<RBFFunctionInterface>( new TPSFunction() ); rbfInterpolator = shared_ptr<RBFInterpolation>( new RBFInterpolation( rbfFunction ) ); rbfInterpToMesh = shared_ptr<RBFCoarsening> ( new RBFCoarsening( rbfInterpolator ) ); shared_ptr<MultiLevelSolver> fluidSolver( new MultiLevelSolver( fluid, fluid, rbfInterpToCouplingMesh, rbfInterpToMesh, 0, 0 ) ); rbfFunction = shared_ptr<RBFFunctionInterface>( new TPSFunction() ); rbfInterpolator = shared_ptr<RBFInterpolation>( new RBFInterpolation( rbfFunction ) ); rbfInterpToCouplingMesh = shared_ptr<RBFCoarsening> ( new RBFCoarsening( rbfInterpolator ) ); rbfFunction = shared_ptr<RBFFunctionInterface>( new TPSFunction() ); rbfInterpolator = shared_ptr<RBFInterpolation>( new RBFInterpolation( rbfFunction ) ); rbfInterpToMesh = shared_ptr<RBFCoarsening> ( new RBFCoarsening( rbfInterpolator ) ); shared_ptr<MultiLevelSolver> solidSolver( new MultiLevelSolver( solid, fluid, rbfInterpToCouplingMesh, rbfInterpToMesh, 1, 0 ) ); std::shared_ptr< std::list<std::shared_ptr<ConvergenceMeasure> > > convergenceMeasures; convergenceMeasures = std::shared_ptr<std::list<std::shared_ptr<ConvergenceMeasure> > >( new std::list<std::shared_ptr<ConvergenceMeasure> > ); convergenceMeasures->push_back( std::shared_ptr<ConvergenceMeasure>( new ResidualRelativeConvergenceMeasure( 0, false, tol ) ) ); convergenceMeasures->push_back( std::shared_ptr<ConvergenceMeasure>( new MinIterationConvergenceMeasure( 0, false, minIter ) ) ); shared_ptr<MultiLevelFsiSolver> fsi( new MultiLevelFsiSolver( fluidSolver, solidSolver, convergenceMeasures, parallel, extrapolation ) ); shared_ptr<PostProcessing> postProcessing( new AndersonPostProcessing( fsi, maxIter, initialRelaxation, maxUsedIterations, nbReuse, singularityLimit, reuseInformationStartingFromTimeIndex, scaling, beta, updateJacobian ) ); std::shared_ptr<sdc::SDCFsiSolverInterface> sdcFluidSolver = std::dynamic_pointer_cast<sdc::SDCFsiSolverInterface>( fluid ); std::shared_ptr<sdc::SDCFsiSolverInterface> sdcSolidSolver = std::dynamic_pointer_cast<sdc::SDCFsiSolverInterface>( solid ); assert( sdcFluidSolver ); assert( sdcSolidSolver ); std::shared_ptr<fsi::SDCFsiSolver> fsiSolver( new fsi::SDCFsiSolver( sdcFluidSolver, sdcSolidSolver, postProcessing, extrapolation ) ); int nbNodes = 3; std::shared_ptr<fsi::quadrature::IQuadrature<scalar> > quadrature; quadrature = std::shared_ptr<fsi::quadrature::IQuadrature<scalar> >( new fsi::quadrature::GaussLobatto<scalar>( nbNodes ) ); std::shared_ptr<sdc::SDC> sdc( new sdc::SDC( fsiSolver, quadrature, 1.0e-13, 10, 200 ) ); sdc->run(); ASSERT_TRUE( sdc->isConverged() ); fluidSolvers.push_back( fluid ); nbTimeStepsList.push_back( nbTimeSteps ); } for ( int i = 0; i < 2; i++ ) { fsi::vector ref; if ( i == 0 ) ref = fluidSolvers.back()->u; else ref = fluidSolvers.back()->a; std::deque<scalar> errors; for ( int iComputation = 0; iComputation < nbComputations - 1; iComputation++ ) { fsi::vector data; if ( i == 0 ) data = fluidSolvers.at( iComputation )->u; else data = fluidSolvers.at( iComputation )->a; scalar error = (ref - data).norm() / data.norm(); std::cout << "error = " << error << std::endl; errors.push_back( error ); } for ( int iComputation = 0; iComputation < nbComputations - 2; iComputation++ ) { scalar order = ( std::log10( errors.at( iComputation ) ) - std::log10( errors.at( iComputation + 1 ) ) ) / ( std::log10( nbTimeStepsList.at( iComputation + 1 ) ) - std::log10( nbTimeStepsList.at( iComputation ) ) ); std::cout << "order = " << order << std::endl; ASSERT_GE( order, 3.8 ); } } }