//-------------------------------------------------------------- void testApp::update(){ switch (demo) { case OSCILLATIONS:{ ildaFrame.getPolys().clear(); ildaFrame.addPoly(ofFloatColor( (int)ofGetElapsedTimef()%3, (int)ofGetElapsedTimef()%5, (int)ofGetElapsedTimef()%7, 1)); ofxIlda::Poly& p = ildaFrame.getLastPoly(); p.clear(); for (int i = 0 ; i < 35 ; i ++){ float t = (ofGetElapsedTimef() + i * 0.5); float scale = sqrt(abs(sin(ofGetElapsedTimef()))); ofPoint pnt = (ofPoint(0.5,0.5) + scale * ofPoint(0.5*cos(t*1.1), 0.5*sin(t))); p.lineTo(pnt); } break; } case MILKYWAY:{ ildaFrame.getPolys().clear(); ildaFrame.addPoly(ofFloatColor( (int)ofGetElapsedTimef()%11, (int)ofGetElapsedTimef()%5, (int)ofGetElapsedTimef()%7, 1)); ofxIlda::Poly& q = ildaFrame.getLastPoly(); q.clear(); for (int i = 0 ; i < 150 ; i ++){ float t = (ofGetElapsedTimef() + i*0.5); float scale = sqrt(i/150.0); ofPoint pnt = (ofPoint(0.5,0.5) + scale * ofPoint(0.5*cos(t*1.1), 0.5*sin(t))); q.lineTo(pnt); } break; } default: ildaFrame.clear(); break; } // drawSomething(EYE, ofPoint(0.5,0.5), 0.2, ofFloatColor(0,1,1,1)); drawSomething(TRIANGLE, ofPoint(0.5,0.5), 0.05*(sqrt(ofGetSystemTime()%53)), ofFloatColor(1,0,0,1)); drawSomething(TRIANGLE, ofPoint(0.5,0.5), 0.05*(sqrt(ofGetSystemTime()%73)), ofFloatColor(0,0,1,1)); drawSomething(TRIANGLE, ofPoint(0.5,0.5), 0.05*(sqrt(ofGetSystemTime()%101)), ofFloatColor(1,1,0,1)); }
/************************************************************* Create the geometry **************************************************************/ void MakeGeometry(void) { int i; double radius = 0.5; static double theta = 0; GLfloat mshin1[] = {5.0}; /* For the sphere */ GLfloat mspec1[] = {0.5,0.5,0.5,1.0}; GLfloat mdiff1[] = {0.6,0.0,0.6,1.0}; GLfloat mamb1[] = {0.1,0.0,0.1,1.0}; GLfloat mdiff2[] = {0.0,1.0,0.0,1.0}; /* Green plane */ GLfloat mamb2[] = {0.0,0.2,0.0,1.0}; drawAxises(500, 2.0); drawGrayBox(200); drawGrid(1000); drawSomething(); // yellow square drawSomething2(); // small purple square drawSomething3(); // two chads near the origin drawBresenhamCircle(); // drawDetector(); }
virtual void onDrawContent(SkCanvas* canvas) { drawSomething(canvas); SkPicture* pict = new SkPicture; SkAutoUnref aur(pict); drawSomething(pict->beginRecording(100, 100)); pict->endRecording(); canvas->save(); canvas->translate(SkIntToScalar(300), SkIntToScalar(50)); canvas->scale(-SK_Scalar1, -SK_Scalar1); canvas->translate(-SkIntToScalar(100), -SkIntToScalar(50)); canvas->drawPicture(*pict); canvas->restore(); canvas->save(); canvas->translate(SkIntToScalar(200), SkIntToScalar(150)); canvas->scale(SK_Scalar1, -SK_Scalar1); canvas->translate(0, -SkIntToScalar(50)); canvas->drawPicture(*pict); canvas->restore(); canvas->save(); canvas->translate(SkIntToScalar(100), SkIntToScalar(100)); canvas->scale(-SK_Scalar1, SK_Scalar1); canvas->translate(-SkIntToScalar(100), 0); canvas->drawPicture(*pict); canvas->restore(); #ifdef SK_DEVELOPER if (false) { SkDebugfDumper dumper; SkDumpCanvas dumpCanvas(&dumper); dumpCanvas.drawPicture(*pict); } #endif // test that we can re-record a subpicture, and see the results SkMWCRandom rand(SampleCode::GetAnimTime()); canvas->translate(SkIntToScalar(10), SkIntToScalar(250)); drawCircle(fSubPicture->beginRecording(50, 50), 25, rand.nextU() | 0xFF000000); canvas->drawPicture(*fPicture); delayInval(500); }
void handle_activity_lifecycle_events(struct android_app* app, int32_t cmd) { // LOGI(2, "%d: redraw %d", cmd, app->redrawNeeded); switch (cmd) { case APP_CMD_INIT_WINDOW: // LOGI(2, "window initialized"); drawSomething(app); break; } }
MainWindow::MainWindow(QWidget *parent) : QMainWindow(parent), ui(new Ui::MainWindow) { ui->setupUi(this); this->setWindowTitle("PCL viewer"); qvtkWidget = new QVTKWidget; ui->verticalLayout->addWidget(qvtkWidget); //qvtkWidget = vtkRenderer::New(); cloud.reset (new PointCloudT); grabberThread = new QThread(); grabber = new Grabber(); grabber->moveToThread(grabberThread); grabberThread->start(); grabber->initCamera(); connect(ui->startButton, SIGNAL(released()), this, SLOT(startButtonPressed()) ); connect(ui->updateButton, SIGNAL(released()), this, SLOT(updateButtonPressed()) ); connect(grabber, SIGNAL(currentFrames(int)), ui->framesLabel, SLOT(setNum(int))); connect(ui->drawButton, SIGNAL(released()), this, SLOT(drawSomething())); connect(ui->viewButton_1, SIGNAL(released()), this, SLOT(view_1())); connect(ui->viewButton_2, SIGNAL(released()), this, SLOT(view_2())); connect(ui->viewButton_3, SIGNAL(released()), this, SLOT(view_3())); connect(ui->horizontalSlider, SIGNAL(valueChanged(int)), this, SLOT(view_2())); connect(ui->horizontalSlider_2, SIGNAL(valueChanged(int)), this, SLOT(view_2())); connect(ui->horizontalSlider_3, SIGNAL(valueChanged(int)), this, SLOT(view_2())); connect(ui->horizontalSlider_4, SIGNAL(valueChanged(int)), this, SLOT(view_2())); connect(ui->horizontalSlider_5, SIGNAL(valueChanged(int)), this, SLOT(view_2())); connect(ui->horizontalSlider_6, SIGNAL(valueChanged(int)), this, SLOT(view_2())); connect(ui->horizontalSlider_7, SIGNAL(valueChanged(int)), this, SLOT(view_2())); connect(ui->horizontalSlider_8, SIGNAL(valueChanged(int)), this, SLOT(view_2())); connect(ui->horizontalSlider_9, SIGNAL(valueChanged(int)), this, SLOT(view_2())); connect(ui->horizontalSlider_10, SIGNAL(valueChanged(int)), this, SLOT(view_2())); connect(ui->horizontalSlider_11, SIGNAL(valueChanged(int)), this, SLOT(view_2())); connect(ui->horizontalSlider_12, SIGNAL(valueChanged(int)), this, SLOT(view_2())); //QString fileName = "res/"; //QImage Image = QImage(fileName,"PNM"); //int width = Image.width(); //ui->label->setPixmap(QPixmap::fromImage(image)); }
void android_main(struct android_app* app) { // Make sure glue isn't stripped. app_dummy(); USERDATA userData; userData.xMove = 0; userData.prevWst = -1; app->userData = &userData; app->onAppCmd = handle_activity_lifecycle_events; app->onInputEvent = handle_input_events; while (1) { int ident, events; struct android_poll_source* source; if ((ident=ALooper_pollOnce(app->redrawNeeded?0:-1, NULL, &events, (void**)&source)) >= 0) { if (NULL!=source) { source->process(app, source); } if (app->redrawNeeded) { drawSomething(app); } } } }
static SkImageFilter* make_image_filter(bool canBeNull) { SkImageFilter* filter = 0; // Add a 1 in 3 chance to get a nullptr input if (canBeNull && (R(3) == 1)) { return filter; } enum { ALPHA_THRESHOLD, MERGE, COLOR, LUT3D, BLUR, MAGNIFIER, DOWN_SAMPLE, XFERMODE, OFFSET, MATRIX, MATRIX_CONVOLUTION, COMPOSE, DISTANT_LIGHT, POINT_LIGHT, SPOT_LIGHT, NOISE, DROP_SHADOW, MORPHOLOGY, BITMAP, DISPLACE, TILE, PICTURE, PAINT, NUM_FILTERS }; switch (R(NUM_FILTERS)) { case ALPHA_THRESHOLD: filter = SkAlphaThresholdFilter::Create(make_region(), make_scalar(), make_scalar()); break; case MERGE: filter = SkMergeImageFilter::Create(make_image_filter(), make_image_filter(), make_xfermode()); break; case COLOR: { SkAutoTUnref<SkColorFilter> cf(make_color_filter()); filter = cf.get() ? SkColorFilterImageFilter::Create(cf, make_image_filter()) : 0; } break; case LUT3D: { int cubeDimension; SkAutoDataUnref lut3D(make_3Dlut(&cubeDimension, (R(2) == 1), (R(2) == 1), (R(2) == 1))); SkAutoTUnref<SkColorFilter> cf(SkColorCubeFilter::Create(lut3D, cubeDimension)); filter = cf.get() ? SkColorFilterImageFilter::Create(cf, make_image_filter()) : 0; } break; case BLUR: filter = SkBlurImageFilter::Create(make_scalar(true), make_scalar(true), make_image_filter()); break; case MAGNIFIER: filter = SkMagnifierImageFilter::Create(make_rect(), make_scalar(true)); break; case DOWN_SAMPLE: filter = SkDownSampleImageFilter::Create(make_scalar()); break; case XFERMODE: { SkAutoTUnref<SkXfermode> mode(SkXfermode::Create(make_xfermode())); filter = SkXfermodeImageFilter::Create(mode, make_image_filter(), make_image_filter()); } break; case OFFSET: filter = SkOffsetImageFilter::Create(make_scalar(), make_scalar(), make_image_filter()); break; case MATRIX: filter = SkImageFilter::CreateMatrixFilter(make_matrix(), (SkFilterQuality)R(4), make_image_filter()); break; case MATRIX_CONVOLUTION: { SkImageFilter::CropRect cropR(SkRect::MakeWH(SkIntToScalar(kBitmapSize), SkIntToScalar(kBitmapSize))); SkISize size = SkISize::Make(R(10)+1, R(10)+1); int arraySize = size.width() * size.height(); SkTArray<SkScalar> kernel(arraySize); for (int i = 0; i < arraySize; ++i) { kernel.push_back() = make_scalar(); } SkIPoint kernelOffset = SkIPoint::Make(R(SkIntToScalar(size.width())), R(SkIntToScalar(size.height()))); filter = SkMatrixConvolutionImageFilter::Create(size, kernel.begin(), make_scalar(), make_scalar(), kernelOffset, (SkMatrixConvolutionImageFilter::TileMode)R(3), R(2) == 1, make_image_filter(), &cropR); } break; case COMPOSE: filter = SkComposeImageFilter::Create(make_image_filter(), make_image_filter()); break; case DISTANT_LIGHT: filter = (R(2) == 1) ? SkLightingImageFilter::CreateDistantLitDiffuse(make_point(), make_color(), make_scalar(), make_scalar(), make_image_filter()) : SkLightingImageFilter::CreateDistantLitSpecular(make_point(), make_color(), make_scalar(), make_scalar(), SkIntToScalar(R(10)), make_image_filter()); break; case POINT_LIGHT: filter = (R(2) == 1) ? SkLightingImageFilter::CreatePointLitDiffuse(make_point(), make_color(), make_scalar(), make_scalar(), make_image_filter()) : SkLightingImageFilter::CreatePointLitSpecular(make_point(), make_color(), make_scalar(), make_scalar(), SkIntToScalar(R(10)), make_image_filter()); break; case SPOT_LIGHT: filter = (R(2) == 1) ? SkLightingImageFilter::CreateSpotLitDiffuse(SkPoint3::Make(0, 0, 0), make_point(), make_scalar(), make_scalar(), make_color(), make_scalar(), make_scalar(), make_image_filter()) : SkLightingImageFilter::CreateSpotLitSpecular(SkPoint3::Make(0, 0, 0), make_point(), make_scalar(), make_scalar(), make_color(), make_scalar(), make_scalar(), SkIntToScalar(R(10)), make_image_filter()); break; case NOISE: { SkAutoTUnref<SkShader> shader((R(2) == 1) ? SkPerlinNoiseShader::CreateFractalNoise( make_scalar(true), make_scalar(true), R(10.0f), make_scalar()) : SkPerlinNoiseShader::CreateTurbulence( make_scalar(true), make_scalar(true), R(10.0f), make_scalar())); SkPaint paint; paint.setShader(shader); SkImageFilter::CropRect cropR(SkRect::MakeWH(SkIntToScalar(kBitmapSize), SkIntToScalar(kBitmapSize))); filter = SkPaintImageFilter::Create(paint, &cropR); } break; case DROP_SHADOW: filter = SkDropShadowImageFilter::Create(make_scalar(), make_scalar(), make_scalar(true), make_scalar(true), make_color(), make_shadow_mode(), make_image_filter(), nullptr); break; case MORPHOLOGY: if (R(2) == 1) { filter = SkDilateImageFilter::Create(R(static_cast<float>(kBitmapSize)), R(static_cast<float>(kBitmapSize)), make_image_filter()); } else { filter = SkErodeImageFilter::Create(R(static_cast<float>(kBitmapSize)), R(static_cast<float>(kBitmapSize)), make_image_filter()); } break; case BITMAP: { SkAutoTUnref<SkImage> image(SkImage::NewFromBitmap(make_bitmap())); if (R(2) == 1) { filter = SkImageSource::Create(image, make_rect(), make_rect(), kHigh_SkFilterQuality); } else { filter = SkImageSource::Create(image); } } break; case DISPLACE: filter = SkDisplacementMapEffect::Create(make_channel_selector_type(), make_channel_selector_type(), make_scalar(), make_image_filter(false), make_image_filter()); break; case TILE: filter = SkTileImageFilter::Create(make_rect(), make_rect(), make_image_filter(false)); break; case PICTURE: { SkRTreeFactory factory; SkPictureRecorder recorder; SkCanvas* recordingCanvas = recorder.beginRecording(SkIntToScalar(kBitmapSize), SkIntToScalar(kBitmapSize), &factory, 0); drawSomething(recordingCanvas); SkAutoTUnref<SkPicture> pict(recorder.endRecording()); filter = SkPictureImageFilter::Create(pict.get(), make_rect()); } break; case PAINT: { SkImageFilter::CropRect cropR(make_rect()); filter = SkPaintImageFilter::Create(make_paint(), &cropR); } default: break; } return (filter || canBeNull) ? filter : make_image_filter(canBeNull); }
DEF_TEST(Serialization, reporter) { // Test matrix serialization { SkMatrix matrix = SkMatrix::I(); TestObjectSerialization(&matrix, reporter); } // Test path serialization { SkPath path; TestObjectSerialization(&path, reporter); } // Test region serialization { SkRegion region; TestObjectSerialization(®ion, reporter); } // Test rrect serialization { // SkRRect does not initialize anything. // An uninitialized SkRRect can be serialized, // but will branch on uninitialized data when deserialized. SkRRect rrect; SkRect rect = SkRect::MakeXYWH(1, 2, 20, 30); SkVector corners[4] = { {1, 2}, {2, 3}, {3,4}, {4,5} }; rrect.setRectRadii(rect, corners); TestAlignment(&rrect, reporter); } // Test readByteArray { unsigned char data[kArraySize] = { 1, 2, 3 }; TestArraySerialization(data, reporter); } // Test readColorArray { SkColor data[kArraySize] = { SK_ColorBLACK, SK_ColorWHITE, SK_ColorRED }; TestArraySerialization(data, reporter); } // Test readIntArray { int32_t data[kArraySize] = { 1, 2, 4, 8 }; TestArraySerialization(data, reporter); } // Test readPointArray { SkPoint data[kArraySize] = { {6, 7}, {42, 128} }; TestArraySerialization(data, reporter); } // Test readScalarArray { SkScalar data[kArraySize] = { SK_Scalar1, SK_ScalarHalf, SK_ScalarMax }; TestArraySerialization(data, reporter); } // Test invalid deserializations { SkImageInfo info = SkImageInfo::MakeN32Premul(kBitmapSize, kBitmapSize); SkBitmap validBitmap; validBitmap.setConfig(info); // Create a bitmap with a really large height info.fHeight = 1000000000; SkBitmap invalidBitmap; invalidBitmap.setConfig(info); // The deserialization should succeed, and the rendering shouldn't crash, // even when the device fails to initialize, due to its size TestBitmapSerialization(validBitmap, invalidBitmap, true, reporter); } // Test simple SkPicture serialization { SkPictureRecorder recorder; bool didDraw = drawSomething(recorder.beginRecording(kBitmapSize, kBitmapSize)); REPORTER_ASSERT(reporter, didDraw); SkAutoTUnref<SkPicture> pict(recorder.endRecording()); // Serialize picture SkWriteBuffer writer(SkWriteBuffer::kValidation_Flag); pict->flatten(writer); size_t size = writer.bytesWritten(); SkAutoTMalloc<unsigned char> data(size); writer.writeToMemory(static_cast<void*>(data.get())); // Deserialize picture SkValidatingReadBuffer reader(static_cast<void*>(data.get()), size); SkAutoTUnref<SkPicture> readPict( SkPicture::CreateFromBuffer(reader)); REPORTER_ASSERT(reporter, NULL != readPict.get()); } }
static sk_sp<SkImageFilter> make_image_filter(bool canBeNull) { sk_sp<SkImageFilter> filter; // Add a 1 in 3 chance to get a nullptr input uint8_t i; fuzz->nextRange(&i, 0, 2); if (fuzz->exhausted() || (canBeNull && i == 1)) { return filter; } enum { ALPHA_THRESHOLD, MERGE, COLOR, BLUR, MAGNIFIER, BLENDMODE, OFFSET, MATRIX, MATRIX_CONVOLUTION, COMPOSE, DISTANT_LIGHT, POINT_LIGHT, SPOT_LIGHT, NOISE, DROP_SHADOW, MORPHOLOGY, BITMAP, DISPLACE, TILE, PICTURE, PAINT, NUM_FILTERS }; uint8_t s; fuzz->nextRange(&s, 0, NUM_FILTERS - 1); switch (s) { case ALPHA_THRESHOLD: { SkRegion reg = make_region(); SkScalar innerMin, outerMax; fuzz->next(&innerMin, &outerMax); sk_sp<SkImageFilter> fil = make_image_filter(); filter = SkAlphaThresholdFilter::Make(reg, innerMin, outerMax, fil); break; } case MERGE: { sk_sp<SkImageFilter> filA = make_image_filter(); sk_sp<SkImageFilter> filB = make_image_filter(); filter = SkMergeImageFilter::Make(filA, filB); break; } case COLOR: { sk_sp<SkColorFilter> cf(make_color_filter()); filter = cf ? SkColorFilterImageFilter::Make(std::move(cf), make_image_filter()) : nullptr; break; } case BLUR: { SkScalar sX = make_number(true); SkScalar sY = make_number(true); sk_sp<SkImageFilter> fil = make_image_filter(); filter = SkBlurImageFilter::Make(sX, sY, fil); break; } case MAGNIFIER: { SkRect rect = make_rect(); SkScalar inset = make_number(true); sk_sp<SkImageFilter> fil = make_image_filter(); filter = SkMagnifierImageFilter::Make(rect, inset, fil); break; } case BLENDMODE: { SkBlendMode mode = make_blendmode(); sk_sp<SkImageFilter> filA = make_image_filter(); sk_sp<SkImageFilter> filB = make_image_filter(); filter = SkXfermodeImageFilter::Make(mode, filA, filB, nullptr); break; } case OFFSET: { SkScalar dx, dy; fuzz->next(&dx, &dy); sk_sp<SkImageFilter> fil = make_image_filter(); filter = SkOffsetImageFilter::Make(dx, dy, fil); break; } case MATRIX: { SkMatrix m; init_matrix(&m); int qual; fuzz->nextRange(&qual, 0, SkFilterQuality::kLast_SkFilterQuality - 1); sk_sp<SkImageFilter> fil = make_image_filter(); filter = SkImageFilter::MakeMatrixFilter(m, (SkFilterQuality)qual, fil); break; } case MATRIX_CONVOLUTION: { SkImageFilter::CropRect cropR(SkRect::MakeWH(SkIntToScalar(kBitmapSize), SkIntToScalar(kBitmapSize))); int w, h; fuzz->nextRange(&w, 1, 10); fuzz->nextRange(&h, 1, 10); SkISize size = SkISize::Make(w, h); int arraySize = size.width() * size.height(); SkTArray<SkScalar> kernel(arraySize); for (int i = 0; i < arraySize; ++i) { kernel.push_back() = make_number(false); } fuzz->nextRange(&w, 0, size.width() - 1); fuzz->nextRange(&h, 0, size.height() - 1); SkIPoint kernelOffset = SkIPoint::Make(w, h); int mode; fuzz->nextRange(&mode, 0, SkMatrixConvolutionImageFilter::kMax_TileMode - 1); bool convolveAlpha = make_bool(); SkScalar gain, bias; fuzz->next(&gain, &bias); sk_sp<SkImageFilter> fil = make_image_filter(); filter = SkMatrixConvolutionImageFilter::Make(size, kernel.begin(), gain, bias, kernelOffset, (SkMatrixConvolutionImageFilter::TileMode)mode, convolveAlpha, fil, &cropR); break; } case COMPOSE: { sk_sp<SkImageFilter> filA = make_image_filter(); sk_sp<SkImageFilter> filB = make_image_filter(); filter = SkComposeImageFilter::Make(filA, filB); break; } case DISTANT_LIGHT: { SkPoint3 p = make_point(); SkColor c = make_color(); SkScalar ss, kd; fuzz->next(&ss, &kd); int shininess; fuzz->nextRange(&shininess, 0, 9); sk_sp<SkImageFilter> fil = make_image_filter(); filter = make_bool() ? SkLightingImageFilter::MakeDistantLitDiffuse(p, c, ss, kd, fil) : SkLightingImageFilter::MakeDistantLitSpecular(p, c, ss, kd, shininess, fil); break; } case POINT_LIGHT: { SkPoint3 p = make_point(); SkColor c = make_color(); SkScalar ss, kd; fuzz->next(&ss, &kd); int shininess; fuzz->nextRange(&shininess, 0, 9); sk_sp<SkImageFilter> fil = make_image_filter(); filter = make_bool() ? SkLightingImageFilter::MakePointLitDiffuse(p, c, ss, kd, fil) : SkLightingImageFilter::MakePointLitSpecular(p, c, ss, kd, shininess, fil); break; } case SPOT_LIGHT: { SkPoint3 p = make_point(); SkColor c = make_color(); SkScalar se, ca, ss, kd; fuzz->next(&se, &ca, &ss, &kd); int shininess; fuzz->nextRange(&shininess, 0, 9); sk_sp<SkImageFilter> fil = make_image_filter(); filter = make_bool() ? SkLightingImageFilter::MakeSpotLitDiffuse(SkPoint3::Make(0, 0, 0), p, se, ca, c, ss, kd, fil) : SkLightingImageFilter::MakeSpotLitSpecular(SkPoint3::Make(0, 0, 0), p, se, ca, c, ss, kd, shininess, fil); break; } case NOISE: { SkScalar bfx = make_number(true); SkScalar bfy = make_number(true); SkScalar seed = make_number(false); int octaves; fuzz->nextRange(&octaves, 0, 9); sk_sp<SkShader> shader(make_bool() ? SkPerlinNoiseShader::MakeFractalNoise(bfx, bfy, octaves, seed) : SkPerlinNoiseShader::MakeTurbulence(bfx, bfy, octaves, seed)); SkPaint paint; paint.setShader(shader); SkImageFilter::CropRect cropR(SkRect::MakeWH(SkIntToScalar(kBitmapSize), SkIntToScalar(kBitmapSize))); filter = SkPaintImageFilter::Make(paint, &cropR); break; } case DROP_SHADOW: { SkScalar dx, dy, sx, sy; fuzz->next(&dx, &dy); sx = make_number(true); sy = make_number(true); SkColor c = make_color(); SkDropShadowImageFilter::ShadowMode mode = make_shadow_mode(); sk_sp<SkImageFilter> fil = make_image_filter(); filter = SkDropShadowImageFilter::Make(dx, dy, sx, sy, c, mode, fil, nullptr); break; } case MORPHOLOGY: { int rx, ry; fuzz->nextRange(&rx, 0, kBitmapSize); fuzz->nextRange(&ry, 0, kBitmapSize); sk_sp<SkImageFilter> fil = make_image_filter(); if (make_bool()) { filter = SkDilateImageFilter::Make(rx, ry, fil); } else { filter = SkErodeImageFilter::Make(rx, ry, fil); } break; } case BITMAP: { sk_sp<SkImage> image(SkImage::MakeFromBitmap(make_bitmap())); if (make_bool()) { filter = SkImageSource::Make(std::move(image), make_rect(), make_rect(), kHigh_SkFilterQuality); } else { filter = SkImageSource::Make(std::move(image)); } break; } case DISPLACE: { SkDisplacementMapEffect::ChannelSelectorType x = make_channel_selector_type(); SkDisplacementMapEffect::ChannelSelectorType y = make_channel_selector_type(); SkScalar scale = make_number(false); sk_sp<SkImageFilter> filA = make_image_filter(false); sk_sp<SkImageFilter> filB = make_image_filter(); filter = SkDisplacementMapEffect::Make(x, y, scale, filA, filB); break; } case TILE: { SkRect src = make_rect(); SkRect dest = make_rect(); sk_sp<SkImageFilter> fil = make_image_filter(false); filter = SkTileImageFilter::Make(src, dest, fil); break; } case PICTURE: { SkRTreeFactory factory; SkPictureRecorder recorder; SkCanvas* recordingCanvas = recorder.beginRecording(SkIntToScalar(kBitmapSize), SkIntToScalar(kBitmapSize), &factory, 0); drawSomething(recordingCanvas); sk_sp<SkPicture> pict(recorder.finishRecordingAsPicture()); filter = SkPictureImageFilter::Make(pict, make_rect()); break; } case PAINT: { SkImageFilter::CropRect cropR(make_rect()); filter = SkPaintImageFilter::Make(make_paint(), &cropR); break; } default: break; } return filter; }