PNM* MorphologicalOperator::transform()
{
int size = getParameter("size").toInt();
SE shape = (MorphologicalOperator::SE) getParameter("shape").toInt();
PNM* newImage = new PNM(image->width(), image->height(), QImage::Format_RGB32);
int width = image->width();
int height = image->height();
math::matrix<bool> elementStrukturyzujacy = getSE(size, shape);
for(int x = 0; x < width; x++)
for(int y = 0; y < height; y++)
{
math::matrix<double> windowR = getWindow(x, y, size, RChannel, RepeatEdge);
math::matrix<double> windowG = getWindow(x, y, size, GChannel, RepeatEdge);
math::matrix<double> windowB = getWindow(x, y, size, BChannel, RepeatEdge);
newImage->setPixel(x, y, qRgb(morph(windowR, elementStrukturyzujacy), morph(windowG, elementStrukturyzujacy), morph(windowB, elementStrukturyzujacy)));
}
return newImage;
}
int main(int argc, char *argv[], char *envp[])
{
morph();
winmain();
return 0;
}
cv::Mat MOG2ForegroundMaskCalculator::calculate(cv::Mat nextFrame) {
cv::Mat mask;
bgSub->apply(nextFrame, mask, 0.001);
removeShadows(mask);
morph(mask);
return mask;
}
int main (int argc, char *argv[]) {
//~ test_bill_house();
if (argc != 7) {
fprintf(stderr, "Wrong number of arguments");
return EXIT_FAILURE;
}
// setup
char *src_path = argv[1];
char *dst_path = argv[2];
char *out_path = argv[3];
char *segments_path = argv[4];
int n_frames = atoi(argv[5]);
int fps = atoi(argv[6]);
FILE *segments_file = fopen(segments_path, "r");
int n_segments;
read_int(segments_file, &n_segments);
segment src_segments[n_segments];
segment dst_segments[n_segments];
read_segments(segments_file, src_segments, n_segments);
read_segments(segments_file, dst_segments, n_segments);
fclose(segments_file);
IplImage *src_image, *dst_image;
if ((src_image = cvLoadImage(src_path, CV_LOAD_IMAGE_COLOR)) == 0) {
fprintf(stderr, "Couldn't load source image\n");
exit(EXIT_FAILURE);
}
if ((dst_image = cvLoadImage(dst_path, CV_LOAD_IMAGE_COLOR)) == 0) {
fprintf(stderr, "Couldn't load destination image\n");
exit(EXIT_FAILURE);
}
CvVideoWriter *writer = create_video_writer(out_path, src_image->width, src_image->height, fps);
if(writer == NULL) {
fprintf(stderr, "Cannot create video writer\n");
exit(EXIT_FAILURE);
}
// morph
morph(src_image, dst_image, src_segments, dst_segments, n_segments, n_frames, writer, ASM);
cvReleaseImage(&src_image);
cvReleaseImage(&dst_image);
cvReleaseVideoWriter(&writer);
return EXIT_SUCCESS;
}
void
MorphShape::display(Renderer& renderer, const Transform& base)
{
morph();
const Transform xform = base * transform();
_def->display(renderer, _shape, xform);
clear_invalidated();
}
int main(int argc, char *argv[], char *envp[])
{
_envargs(&argc,&argv,"HANEDIT2OPT");
argcheck(argc,argv);
#ifdef DEBUG
morph();
#endif
winmain();
return 0;
}
/* sets the new target brightness of LEDs */
void setTarget2(float color[], int fadeMS)
{
pauseLED=1;
morph(origin); //seed origin with current colour
copyColourArray(color,target); //seed target with passed colour
stepIndex=0;
stepCount=fadeMS/MORPH_TIMER_MS;
pauseLED=0;
}
//morph images to fill the PsPdStore
int ImageHandler::fillPsPdStore(int N,const char* keypointfilename)
{
int positionJ = 1;
//bool incrementflag= false;
for(int i = 0; i < N-1;i++)
{
//incrememnt flag is for positionJ, only want to increment every other iteration
//if(i%2 == 0) incrementflag = true;
// else incrementflag = false;
if(morph(sourceImage,PsPdStore.at(i), keypointfilename,positionJ,true)== -1)return -1;
i++;
if(morph(destImage,PsPdStore.at(i),keypointfilename,positionJ,false)==-1)return -1;
//increment position J, refering to the jth keypoint every other iteration
//if(incrementflag)
positionJ++;
}
return 0;
}
//calculate led power usage
float getTotalLEDPower()
{
float v[LEDS];
morph(v);
float totalPower=0;
float divisor=1.0f/256.0f;
for (int i=0; i<LEDS; i++)
{ totalPower += v[i]*(float)ledPowerMap[i]*divisor;
}
return totalPower;
}
void morph_ifs ( void )
{
FILE *stream;
stream= fopen( "hilist.dat", "rb" );
while( fread( morph_list, 4, _MAX_POINT, stream ) == _MAX_POINT )
{
morph();
chaos();
wait_count( 70 * 1 );
}
fclose( stream );
}
virtual const char* next(){
current.reset();
const char * s = item.next();
current.append_array(s, strlen(s) + 1);
if (last.content_size() == 0) {
str.reset();
last.reset();
str.append_array(current, current.content_size());
last.append_array(current, current.content_size());
} else {
morph();
}
return str;
}
/* called by timer every 20ms */
void adjustLights()
{
if (!pauseLED)
{ if (stepIndex<stepCount)
{ stepIndex++;
float v[LEDS];
morph(v);
for (int i=0; i<LEDS; i++)
{ v[i]+=offset[i];
}
setLEDs(v);
}
}
}
void Player::render()
{
morph();
glPushMatrix();
//glTranslatef(position.X_Y_Z[0],position.X_Y_Z[1],position.X_Y_Z[2]);
orientation.normalize();
this->directionVec.multiplyVector(orientation);
transform = Matrix44(position,orientation);
transform.copyIntoSingleArray();
glMultMatrixf(transform.OneDmat);
glRotatef(90.f,0,0,1);
glRotatef(90.f,1,0,0);
glBindTexture(GL_TEXTURE_2D, this->modelTexture.texID);
// Begin drawing of triangles.
glmDraw(this->model, GLM_SMOOTH | GLM_TEXTURE);
glPopMatrix();
}
virtual void onDraw(SkCanvas* canvas) {
if (!fInitialized) {
this->make_bitmap();
fInitialized = true;
}
canvas->clear(0x00000000);
{
SkAutoTUnref<SkImageFilter> bitmapSource(new SkBitmapSource(fBitmap));
SkAutoTUnref<SkColorFilter> cf(SkColorFilter::CreateModeFilter(SK_ColorRED,
SkXfermode::kSrcIn_Mode));
SkAutoTUnref<SkImageFilter> blur(new SkBlurImageFilter(4.0f, 4.0f, bitmapSource));
SkAutoTUnref<SkImageFilter> erode(new SkErodeImageFilter(4, 4, blur));
SkAutoTUnref<SkImageFilter> color(SkColorFilterImageFilter::Create(cf, erode));
SkAutoTUnref<SkImageFilter> merge(new SkMergeImageFilter(blur, color));
SkPaint paint;
paint.setImageFilter(merge);
canvas->drawPaint(paint);
}
{
SkAutoTUnref<SkImageFilter> morph(new SkDilateImageFilter(5, 5));
SkScalar matrix[20] = { SK_Scalar1, 0, 0, 0, 0,
0, SK_Scalar1, 0, 0, 0,
0, 0, SK_Scalar1, 0, 0,
0, 0, 0, SkFloatToScalar(0.5f), 0 };
SkAutoTUnref<SkColorFilter> matrixFilter(new SkColorMatrixFilter(matrix));
SkAutoTUnref<SkImageFilter> colorMorph(SkColorFilterImageFilter::Create(matrixFilter, morph));
SkAutoTUnref<SkXfermode> mode(SkXfermode::Create(SkXfermode::kSrcOver_Mode));
SkAutoTUnref<SkImageFilter> blendColor(new SkXfermodeImageFilter(mode, colorMorph));
SkPaint paint;
paint.setImageFilter(blendColor);
canvas->drawBitmap(fBitmap, 100, 0, &paint);
}
}
/* This keeps the directory tree and the map geometry in sync
* (expansion state vs. "deployment" value) */
void
colexp( GNode *dnode, ColExpMesg mesg )
{
static double colexp_time;
static int depth = 0;
static int max_depth;
GNode *node;
double wait_time;
double pan_time;
int wait_count = 0;
boolean curnode_is_ancestor, curnode_is_descendant, curnode_is_equal;
g_assert( NODE_IS_DIR(dnode) );
if (depth == 0) {
#ifdef DEBUG
if (mesg != COLEXP_EXPAND_ANY) {
/* All ancestor directories must be expanded */
node = dnode->parent;
while (NODE_IS_DIR(node)) {
g_assert( DIR_NODE_DESC(node)->deployment > (1.0 - EPSILON) );
node = node->parent;
}
}
#endif
/* Update ctree and determine maximum recursion depth */
switch (mesg) {
case COLEXP_COLLAPSE_RECURSIVE:
dirtree_entry_collapse_recursive( dnode );
max_depth = max_expanded_depth( dnode );
break;
case COLEXP_EXPAND:
dirtree_entry_expand( dnode );
max_depth = 0;
break;
case COLEXP_EXPAND_ANY:
dirtree_entry_expand( dnode );
max_depth = collapsed_depth( dnode );
break;
case COLEXP_EXPAND_RECURSIVE:
dirtree_entry_expand_recursive( dnode );
/* max_depth will be used as a high-water mark */
max_depth = 0;
break;
SWITCH_FAIL
}
/* Make file list appropriately (in)accessible */
filelist_reset_access( );
gui_update( );
/* Collapse/expand time for current visualization mode */
switch (globals.fsv_mode) {
case FSV_DISCV:
colexp_time = DISCV_COLEXP_TIME;
break;
case FSV_MAPV:
colexp_time = MAPV_COLEXP_TIME;
break;
case FSV_TREEV:
colexp_time = TREEV_COLEXP_TIME;
break;
SWITCH_FAIL
}
}
morph_break( &DIR_NODE_DESC(dnode)->deployment );
/* Determine time to wait before collapsing/expanding directory */
switch (mesg) {
case COLEXP_COLLAPSE_RECURSIVE:
wait_count = max_depth - depth;
break;
case COLEXP_EXPAND_RECURSIVE:
case COLEXP_EXPAND:
wait_count = depth;
break;
case COLEXP_EXPAND_ANY:
wait_count = max_depth - depth;
break;
SWITCH_FAIL
}
if (wait_count > 0) {
wait_time = (double)wait_count * colexp_time;
morph( &DIR_NODE_DESC(dnode)->deployment, MORPH_LINEAR, DIR_NODE_DESC(dnode)->deployment, wait_time );
}
/* Initiate collapse/expand */
switch (mesg) {
case COLEXP_COLLAPSE_RECURSIVE:
morph_full( &DIR_NODE_DESC(dnode)->deployment, MORPH_QUADRATIC, 0.0, colexp_time, colexp_progress_cb, colexp_progress_cb, dnode );
break;
case COLEXP_EXPAND:
case COLEXP_EXPAND_ANY:
case COLEXP_EXPAND_RECURSIVE:
morph_full( &DIR_NODE_DESC(dnode)->deployment, MORPH_INV_QUADRATIC, 1.0, colexp_time, colexp_progress_cb, colexp_progress_cb, dnode );
break;
SWITCH_FAIL
}
/* Recursion */
/* geometry_colexp_initiated( ) is called at differing points below
* because (at least in TreeV mode) notification must always
* proceed from parent to children, and not the other way around */
switch (mesg) {
case COLEXP_EXPAND:
/* Initial collapse/expand notify */
geometry_colexp_initiated( dnode );
/* EXPAND does not walk the tree */
break;
case COLEXP_EXPAND_ANY:
/* Ensure that all parent directories are expanded */
if (NODE_IS_DIR(dnode->parent)) {
++depth;
colexp( dnode->parent, COLEXP_EXPAND_ANY );
--depth;
}
/* Initial collapse/expand notify */
geometry_colexp_initiated( dnode );
break;
case COLEXP_COLLAPSE_RECURSIVE:
case COLEXP_EXPAND_RECURSIVE:
/* Initial collapse/expand notify */
geometry_colexp_initiated( dnode );
/* Perform action on subdirectories */
++depth;
node = dnode->children;
while (node != NULL) {
if (NODE_IS_DIR(node))
colexp( node, mesg );
else
break;
node = node->next;
}
--depth;
break;
SWITCH_FAIL
}
if (mesg == COLEXP_EXPAND_RECURSIVE) {
/* Update high-water mark */
max_depth = MAX(max_depth, depth);
}
if (depth == 0) {
/* Determine position of current node w.r.t. the
* collapsing/expanding directory node */
curnode_is_ancestor = g_node_is_ancestor( globals.current_node, dnode );
curnode_is_equal = globals.current_node == dnode;
curnode_is_descendant = g_node_is_ancestor( dnode, globals.current_node );
/* Handle the camera semi-intelligently if it is not under
* manual control */
if (!camera->manual_control) {
switch (mesg) {
case COLEXP_COLLAPSE_RECURSIVE:
pan_time = (double)(max_depth + 1) * colexp_time;
if (curnode_is_ancestor || curnode_is_equal)
camera_look_at_full( globals.current_node, MORPH_LINEAR, pan_time );
else if (curnode_is_descendant)
camera_look_at_full( dnode, MORPH_LINEAR, pan_time );
break;
case COLEXP_EXPAND:
case COLEXP_EXPAND_RECURSIVE:
if (curnode_is_ancestor || curnode_is_equal) {
pan_time = (double)(max_depth + 1) * colexp_time;
camera_look_at_full( globals.current_node, MORPH_LINEAR, pan_time );
}
break;
case COLEXP_EXPAND_ANY:
/* Don't do anything. Something else
* should already be doing something
* with the camera */
break;
SWITCH_FAIL
}
}
/* If, in TreeV mode, the current node is an ancestor of
* a collapsing/expanding directory, the scrollbars may
* need updating to reflect a new scroll range */
scrollbars_colexp_adjust = FALSE;
if (curnode_is_ancestor && (globals.fsv_mode == FSV_TREEV))
scrollbars_colexp_adjust = TRUE;
}
void onDraw(SkCanvas* canvas) override {
canvas->clear(SK_ColorBLACK);
{
sk_sp<SkImageFilter> bitmapSource(SkImageSource::Make(fImage));
sk_sp<SkColorFilter> cf(SkColorFilter::MakeModeFilter(SK_ColorRED,
SkBlendMode::kSrcIn));
sk_sp<SkImageFilter> blur(SkBlurImageFilter::Make(4.0f, 4.0f, std::move(bitmapSource)));
sk_sp<SkImageFilter> erode(SkErodeImageFilter::Make(4, 4, blur));
sk_sp<SkImageFilter> color(SkColorFilterImageFilter::Make(std::move(cf),
std::move(erode)));
sk_sp<SkImageFilter> merge(SkMergeImageFilter::Make(blur, color,
SkBlendMode::kSrcOver));
SkPaint paint;
paint.setImageFilter(std::move(merge));
canvas->drawPaint(paint);
canvas->translate(SkIntToScalar(100), 0);
}
{
sk_sp<SkImageFilter> morph(SkDilateImageFilter::Make(5, 5, nullptr));
SkScalar matrix[20] = { SK_Scalar1, 0, 0, 0, 0,
0, SK_Scalar1, 0, 0, 0,
0, 0, SK_Scalar1, 0, 0,
0, 0, 0, 0.5f, 0 };
sk_sp<SkColorFilter> matrixFilter(SkColorFilter::MakeMatrixFilterRowMajor255(matrix));
sk_sp<SkImageFilter> colorMorph(SkColorFilterImageFilter::Make(std::move(matrixFilter),
std::move(morph)));
SkPaint paint;
paint.setImageFilter(SkXfermodeImageFilter::Make(SkBlendMode::kSrcOver,
std::move(colorMorph)));
DrawClippedImage(canvas, fImage.get(), paint);
canvas->translate(SkIntToScalar(100), 0);
}
{
SkScalar matrix[20] = { SK_Scalar1, 0, 0, 0, 0,
0, SK_Scalar1, 0, 0, 0,
0, 0, SK_Scalar1, 0, 0,
0, 0, 0, 0.5f, 0 };
sk_sp<SkColorFilter> matrixCF(SkColorFilter::MakeMatrixFilterRowMajor255(matrix));
sk_sp<SkImageFilter> matrixFilter(SkColorFilterImageFilter::Make(std::move(matrixCF),
nullptr));
sk_sp<SkImageFilter> offsetFilter(SkOffsetImageFilter::Make(10.0f, 10.f,
matrixFilter));
SkPaint paint;
paint.setImageFilter(
SkXfermodeImageFilter::MakeArithmetic(0, 1, 1, 0, true,
std::move(matrixFilter),
std::move(offsetFilter),
nullptr));
DrawClippedImage(canvas, fImage.get(), paint);
canvas->translate(SkIntToScalar(100), 0);
}
{
sk_sp<SkImageFilter> blur(SkBlurImageFilter::Make(SkIntToScalar(10),
SkIntToScalar(10),
nullptr));
SkImageFilter::CropRect cropRect(SkRect::MakeWH(SkIntToScalar(95), SkIntToScalar(100)));
SkPaint paint;
paint.setImageFilter(
SkXfermodeImageFilter::Make(SkBlendMode::kSrcIn, std::move(blur), nullptr,
&cropRect));
DrawClippedImage(canvas, fImage.get(), paint);
canvas->translate(SkIntToScalar(100), 0);
}
{
// Dilate -> matrix convolution.
// This tests that a filter using asFragmentProcessor (matrix
// convolution) correctly handles a non-zero source offset
// (supplied by the dilate).
sk_sp<SkImageFilter> dilate(SkDilateImageFilter::Make(5, 5, nullptr));
SkScalar kernel[9] = {
SkIntToScalar(-1), SkIntToScalar( -1 ), SkIntToScalar(-1),
SkIntToScalar(-1), SkIntToScalar( 7 ), SkIntToScalar(-1),
SkIntToScalar(-1), SkIntToScalar( -1 ), SkIntToScalar(-1),
};
SkISize kernelSize = SkISize::Make(3, 3);
SkScalar gain = 1.0f, bias = SkIntToScalar(0);
SkIPoint kernelOffset = SkIPoint::Make(1, 1);
auto tileMode = SkMatrixConvolutionImageFilter::kClamp_TileMode;
bool convolveAlpha = false;
sk_sp<SkImageFilter> convolve(SkMatrixConvolutionImageFilter::Make(kernelSize,
kernel,
gain,
bias,
kernelOffset,
tileMode,
convolveAlpha,
std::move(dilate)));
SkPaint paint;
paint.setImageFilter(std::move(convolve));
DrawClippedImage(canvas, fImage.get(), paint);
canvas->translate(SkIntToScalar(100), 0);
}
{
// Test that crop offsets are absolute, not relative to the parent's crop rect.
sk_sp<SkColorFilter> cf1(SkColorFilter::MakeModeFilter(SK_ColorBLUE,
SkBlendMode::kSrcIn));
sk_sp<SkColorFilter> cf2(SkColorFilter::MakeModeFilter(SK_ColorGREEN,
SkBlendMode::kSrcIn));
SkImageFilter::CropRect outerRect(SkRect::MakeXYWH(SkIntToScalar(10), SkIntToScalar(10),
SkIntToScalar(80), SkIntToScalar(80)));
SkImageFilter::CropRect innerRect(SkRect::MakeXYWH(SkIntToScalar(20), SkIntToScalar(20),
SkIntToScalar(60), SkIntToScalar(60)));
sk_sp<SkImageFilter> color1(SkColorFilterImageFilter::Make(std::move(cf1),
nullptr,
&outerRect));
sk_sp<SkImageFilter> color2(SkColorFilterImageFilter::Make(std::move(cf2),
std::move(color1),
&innerRect));
SkPaint paint;
paint.setImageFilter(std::move(color2));
paint.setColor(SK_ColorRED);
canvas->drawRect(SkRect::MakeXYWH(0, 0, 100, 100), paint);
canvas->translate(SkIntToScalar(100), 0);
}
}
void credits2(void)
{
int i, ch;
int p;
int plast = -1;
clrscr();
centerprint(aa_imgwidth(context) / 2, aa_imgheight(context) / 3, 3, 128, "The", 0);
centerprint(aa_imgwidth(context) / 2, 2 * aa_imgheight(context) / 3, 3, 128, "END", 0);
drawptr = decrand;
params->randomval = 50;
timestuff(0, NULL, draw, 5000000);
drawptr = NULL;
params->randomval = 0;
drawptr = pryc;
timestuff(0, NULL, draw, MAXTIME);
drawptr = NULL;
clrscr();
draw();
load_song("bb3.s3m");
bbupdate();
starttime = endtime = TIME;
play();
bbwait(1);
for (i = 0; i < LOGOHEIGHT; i++) {
aa_puts(context, aa_scrwidth(context) / 2 - 2, LOGOY + i, AA_BOLD, "8 8");
if (i)
aa_puts(context, aa_scrwidth(context) / 2 - 2, LOGOY + i - 1, AA_NORMAL, "8 8");
bbflushwait(100000);
}
aa_puts(context, aa_scrwidth(context) / 2 - 2, LOGOY + i - 1, AA_NORMAL, "8 8");
#define LWIDTH
for (i = aa_scrwidth(context) / 2; i; i--) {
display8();
displaya(i);
bbflushwait(10000);
}
for (; i < 100; i++) {
textclrscr();
displaya(10 * sin(i * M_PI / 100));
display8();
bbflushwait(10000);
}
aa_puts(context, aa_scrwidth(context) / 2 - 9, LOGOY + 3, AA_DIM, "<PROJECT><PROJECT>");
bbflushwait(100000);
aa_puts(context, aa_scrwidth(context) / 2 - 9, LOGOY + 3, AA_NORMAL, "<PROJECT><PROJECT>");
bbflushwait(100000);
aa_puts(context, aa_scrwidth(context) / 2 - 9, LOGOY + 3, AA_BOLD, "<PROJECT><PROJECT>");
bbflushwait(100000);
aa_puts(context, aa_scrwidth(context) / 2 - 9, LOGOY + 3, AA_NORMAL, "<PROJECT><PROJECT>");
bbflushwait(100000);
bbwait(1000000);
for (i = LOGOY; i > 1; i--) {
textclrscr();
displogo(i);
bbflushwait(30000);
}
source = malloc(aa_imgwidth(context) * (aa_imgheight(context)));
target = malloc(aa_imgwidth(context) * (aa_imgheight(context)));
params->dither = AA_NONE;
format(dual ? aa_scrwidth(context) / 2 : aa_scrwidth(context));
p = 0;
while (1) {
if (p != plast) {
getsource();
displaytext(p);
gettarget();
morph();
displaytext(p);
aa_flush(context);
emscripten_sleep(1);
plast = p;
}
again:
emscripten_sleep(100);
#ifndef __DJGPP__
//ch = aa_getkey(context, 100);
ch = AA_NONE;
#else
while ((ch = bbupdate()) == AA_NONE) ;
#endif
switch (ch) {
case '1':
load_song("bb.s3m");
bbupdate();
play();
break;
case '2':
load_song("bb2.s3m");
bbupdate();
play();
break;
case '3':
load_song("bb3.s3m");
bbupdate();
play();
break;
case 'b':
case 'k':
case 'B':
case 'K':
case AA_BACKSPACE:
case AA_UP:
p -= (aa_scrheight(context) - YSTART) / 2 * (dual + 1);
if (p < 0)
p = 0;
break;
case AA_DOWN:
case AA_LEFT:
case 'f':
case 'F':
case ' ':
case 'j':
case 'J':
p += (aa_scrheight(context) - YSTART) / 2 * (dual + 1);
if (p > textsize)
p = textsize;
break;
case 'q':
case 'Q':
case AA_ESC:
finish_stuff = 0;
backconvert(0, 0, aa_scrwidth(context), aa_scrheight(context));
bbupdate();
starttime = endtime = TIME;
drawptr = decbright;
timestuff(0, NULL, draw, 1000000);
textclrscr();
drawptr = NULL;
aa_flush(context);
emscripten_sleep(1);
free(source);
free(target);
return;
default:
goto again;
}
bbupdate();
starttime = endtime = TIME;
}
}
SkPath TextArt::EnvelopeWarp::warp(const std::string& text, SkTypeface* typeface)
{
SkPath warpedPath;
if (text.empty())
return warpedPath;
//prepare paint
SkPaint paint;
paint.setTextSize(SkIntToScalar(64));
paint.setTypeface(typeface);
paint.setTextAlign(SkPaint::kCenter_Align);
//measure Bottom path to center text on it
SkPathMeasure bMeasure(bSkeleton_, false);
SkScalar hBOffset = 0;
if (paint.getTextAlign() != SkPaint::kLeft_Align)
{
SkScalar pathLen = bMeasure.getLength();
if (paint.getTextAlign() == SkPaint::kCenter_Align)
{
pathLen = SkScalarHalf(pathLen);
}
hBOffset += pathLen;
}
//get text boundaries on normal(non-warped) state
{
SkMatrix scaleMartix;
scaleMartix.setIdentity();
SkTextToPathIter iter(text.c_str(), text.size(), paint, true);
const SkPath* glypthPath;
SkScalar xpos;
SkScalar scale = iter.getPathScale();
scaleMartix.setScale(scale, scale);
while (iter.next(&glypthPath, &xpos))
{
if (glypthPath)
{
//prepare resulting transformatiom Matrix
SkMatrix compositeMatrix(scaleMartix);
compositeMatrix.postTranslate(xpos + hBOffset, 0);
SkPath p;
(*glypthPath).transform(compositeMatrix, &p);
//get normal(without any warps) text boundaries
boundsRect_.join( p.getBounds() );
}
}
}
//center text on Top skeleton
SkPathMeasure tMeasure(tSkeleton_, false);
SkScalar hTOffset = 0;
{
if (paint.getTextAlign() != SkPaint::kLeft_Align)
{
SkScalar pathLen = tMeasure.getLength();
if (paint.getTextAlign() == SkPaint::kCenter_Align)
{
pathLen = SkScalarHalf(pathLen);
}
hTOffset += pathLen;
}
}
//warp text on Bottom and Top skeletons
{
SkTextToPathIter iter(text.c_str(), text.size(), paint, true);
SkScalar xpos;
SkMatrix scaleMartix;
SkScalar scale = iter.getPathScale();
scaleMartix.setScale(scale, scale);
SkPath line;
line.lineTo(SkIntToScalar(100), SkIntToScalar(0));
SkPathMeasure lineMeasure(line, false);
SkPathCrossing bCrossing(bSkeleton_);
SkPathCrossing tCrossing(tSkeleton_);
const SkPath* glypthPathOrig;
while (iter.next(&glypthPathOrig, &xpos))
{
if (glypthPathOrig)
{
SkPath glypthPath;
SkRect glypthBound;
glypthBound = (*glypthPathOrig).getBounds();
glypthPathOrig->offset(-glypthBound.fLeft, 0, &glypthPath);
morph(bSkeleton_, bMeasure, bCrossing,
tSkeleton_, tMeasure, tCrossing,
glypthPath, lineMeasure, scaleMartix,
xpos, hBOffset, hTOffset, warpedPath);
}
}
}
return warpedPath;
}
void test_bill_house() {
char *src_path = "bill.bmp";
char *dst_path = "house.bmp";
char *out_path = "billhouse.avi";
IplImage *src_image, *dst_image;
if ((src_image = cvLoadImage(src_path, CV_LOAD_IMAGE_COLOR)) == 0) {
fprintf(stderr, "Couldn't load source image\n");
exit(EXIT_FAILURE);
}
if ((dst_image = cvLoadImage(dst_path, CV_LOAD_IMAGE_COLOR)) == 0) {
fprintf(stderr, "Couldn't load destination image\n");
exit(EXIT_FAILURE);
}
CvVideoWriter *writer = create_video_writer(out_path, src_image->width, src_image->height, 25);
if(writer == NULL) {
fprintf(stderr, "Cannot create video writer\n");
exit(EXIT_FAILURE);
}
int n_segments = 24;
segment src_segments[n_segments];
src_segments[0].from.x = 233;
src_segments[0].from.y = 249;
src_segments[0].to.x = 269;
src_segments[0].to.y = 342;
src_segments[1].from.x = 275;
src_segments[1].from.y = 359;
src_segments[1].to.x = 324;
src_segments[1].to.y = 415;
src_segments[2].from.x = 344;
src_segments[2].from.y = 428;
src_segments[2].to.x = 394;
src_segments[2].to.y = 444;
src_segments[3].from.x = 397;
src_segments[3].from.y = 445;
src_segments[3].to.x = 439;
src_segments[3].to.y = 424;
src_segments[4].from.x = 449;
src_segments[4].from.y = 406;
src_segments[4].to.x = 513;
src_segments[4].to.y = 327;
src_segments[5].from.x = 520;
src_segments[5].from.y = 311;
src_segments[5].to.x = 542;
src_segments[5].to.y = 221;
src_segments[6].from.x = 227;
src_segments[6].from.y = 212;
src_segments[6].to.x = 242;
src_segments[6].to.y = 107;
src_segments[7].from.x = 251;
src_segments[7].from.y = 84;
src_segments[7].to.x = 351;
src_segments[7].to.y = 30;
src_segments[8].from.x = 373;
src_segments[8].from.y = 28;
src_segments[8].to.x = 487;
src_segments[8].to.y = 70;
src_segments[9].from.x = 497;
src_segments[9].from.y = 92;
src_segments[9].to.x = 543;
src_segments[9].to.y = 192;
src_segments[10].from.x = 306;
src_segments[10].from.y = 432;
src_segments[10].to.x = 277;
src_segments[10].to.y = 477;
src_segments[11].from.x = 263;
src_segments[11].from.y = 482;
src_segments[11].to.x = 60;
src_segments[11].to.y = 575;
src_segments[12].from.x = 518;
src_segments[12].from.y = 396;
src_segments[12].to.x = 561;
src_segments[12].to.y = 440;
src_segments[13].from.x = 580;
src_segments[13].from.y = 441;
src_segments[13].to.x = 793;
src_segments[13].to.y = 493;
src_segments[14].from.x = 283;
src_segments[14].from.y = 201;
src_segments[14].to.x = 344;
src_segments[14].to.y = 193;
src_segments[15].from.x = 401;
src_segments[15].from.y = 188;
src_segments[15].to.x = 458;
src_segments[15].to.y = 186;
src_segments[16].from.x = 299;
src_segments[16].from.y = 220;
src_segments[16].to.x = 337;
src_segments[16].to.y = 221;
src_segments[17].from.x = 415;
src_segments[17].from.y = 215;
src_segments[17].to.x = 465;
src_segments[17].to.y = 210;
src_segments[18].from.x = 378;
src_segments[18].from.y = 223;
src_segments[18].to.x = 381;
src_segments[18].to.y = 293;
src_segments[19].from.x = 332;
src_segments[19].from.y = 285;
src_segments[19].to.x = 298;
src_segments[19].to.y = 326;
src_segments[20].from.x = 434;
src_segments[20].from.y = 273;
src_segments[20].to.x = 475;
src_segments[20].to.y = 307;
src_segments[21].from.x = 322;
src_segments[21].from.y = 332;
src_segments[21].to.x = 453;
src_segments[21].to.y = 326;
src_segments[22].from.x = 321;
src_segments[22].from.y = 341;
src_segments[22].to.x = 388;
src_segments[22].to.y = 364;
src_segments[23].from.x = 389;
src_segments[23].from.y = 363;
src_segments[23].to.x = 449;
src_segments[23].to.y = 335;
segment dst_segments[n_segments];
dst_segments[0].from.x = 283;
dst_segments[0].from.y = 223;
dst_segments[0].to.x = 307;
dst_segments[0].to.y = 316;
dst_segments[1].from.x = 317;
dst_segments[1].from.y = 349;
dst_segments[1].to.x = 356;
dst_segments[1].to.y = 428;
dst_segments[2].from.x = 366;
dst_segments[2].from.y = 447;
dst_segments[2].to.x = 412;
dst_segments[2].to.y = 464;
dst_segments[3].from.x = 420;
dst_segments[3].from.y = 462;
dst_segments[3].to.x = 465;
dst_segments[3].to.y = 445;
dst_segments[4].from.x = 482;
dst_segments[4].from.y = 428;
dst_segments[4].to.x = 530;
dst_segments[4].to.y = 343;
dst_segments[5].from.x = 536;
dst_segments[5].from.y = 319;
dst_segments[5].to.x = 573;
dst_segments[5].to.y = 231;
dst_segments[6].from.x = 286;
dst_segments[6].from.y = 198;
dst_segments[6].to.x = 302;
dst_segments[6].to.y = 90;
dst_segments[7].from.x = 314;
dst_segments[7].from.y = 69;
dst_segments[7].to.x = 414;
dst_segments[7].to.y = 13;
dst_segments[8].from.x = 434;
dst_segments[8].from.y = 19;
dst_segments[8].to.x = 527;
dst_segments[8].to.y = 63;
dst_segments[9].from.x = 542;
dst_segments[9].from.y = 82;
dst_segments[9].to.x = 571;
dst_segments[9].to.y = 200;
dst_segments[10].from.x = 320;
dst_segments[10].from.y = 404;
dst_segments[10].to.x = 281;
dst_segments[10].to.y = 437;
dst_segments[11].from.x = 265;
dst_segments[11].from.y = 443;
dst_segments[11].to.x = 92;
dst_segments[11].to.y = 513;
dst_segments[12].from.x = 524;
dst_segments[12].from.y = 417;
dst_segments[12].to.x = 562;
dst_segments[12].to.y = 453;
dst_segments[13].from.x = 572;
dst_segments[13].from.y = 457;
dst_segments[13].to.x = 725;
dst_segments[13].to.y = 520;
dst_segments[14].from.x = 323;
dst_segments[14].from.y = 211;
dst_segments[14].to.x = 395;
dst_segments[14].to.y = 213;
dst_segments[15].from.x = 445;
dst_segments[15].from.y = 213;
dst_segments[15].to.x = 506;
dst_segments[15].to.y = 208;
dst_segments[16].from.x = 336;
dst_segments[16].from.y = 228;
dst_segments[16].to.x = 383;
dst_segments[16].to.y = 229;
dst_segments[17].from.x = 456;
dst_segments[17].from.y = 228;
dst_segments[17].to.x = 500;
dst_segments[17].to.y = 230;
dst_segments[18].from.x = 417;
dst_segments[18].from.y = 235;
dst_segments[18].to.x = 417;
dst_segments[18].to.y = 301;
dst_segments[19].from.x = 378;
dst_segments[19].from.y = 319;
dst_segments[19].to.x = 349;
dst_segments[19].to.y = 354;
dst_segments[20].from.x = 460;
dst_segments[20].from.y = 311;
dst_segments[20].to.x = 489;
dst_segments[20].to.y = 339;
dst_segments[21].from.x = 374;
dst_segments[21].from.y = 364;
dst_segments[21].to.x = 461;
dst_segments[21].to.y = 363;
dst_segments[22].from.x = 372;
dst_segments[22].from.y = 370;
dst_segments[22].to.x = 421;
dst_segments[22].to.y = 381;
dst_segments[23].from.x = 422;
dst_segments[23].from.y = 381;
dst_segments[23].to.x = 460;
dst_segments[23].to.y = 372;
// apply morphing
int n_frames = 100;
//~ unsigned long long start, end;
//~ START_CLOCK(start);
morph(src_image, dst_image, src_segments, dst_segments, n_segments, n_frames, writer, ASM);
//~ STOP_CLOCK(end);
//~ printf("TSC: %llu\n", end - start);
cvReleaseImage(&src_image);
cvReleaseImage(&dst_image);
cvReleaseVideoWriter(&writer);
}
static void drawframe(dynamic_stuff *generate, Gfx **glistpParam,
float t) {
Gfx *glistp;
Vtx *valist[2]; /* Array of vertex lists */
float weights[2]; /* Array of weights */
u16 perspnorm;
int i;
unsigned char a2;
glistp = *glistpParam; /* Copy to local var */
/*
* Set up matricies
*/
/* Z-distance to force for faces */
#define ZDIST (700*4)
guPerspective(&(generate->projection), &perspnorm,
60.0, 320.0/240.0,
ZDIST-500.0, ZDIST+500.0, 1.0);
gSPPerspNormalize(glistp++, perspnorm);
/* guRotate(&(generate->modeling_rotate1), 40.0, 1.0, 1.0, 1.0); */
guTranslate(&(generate->modeling_translate), 0.0, 0.0, 0.0); /* -... */
gSPMatrix(glistp++, OS_K0_TO_PHYSICAL(&(generate->projection)),
G_MTX_PROJECTION|G_MTX_LOAD|G_MTX_NOPUSH);
gSPMatrix(glistp++, OS_K0_TO_PHYSICAL(&(generate->modeling_translate)),
G_MTX_MODELVIEW|G_MTX_LOAD|G_MTX_NOPUSH);
/* gSPMatrix(glistp++, OS_K0_TO_PHYSICAL(&(generate->modeling_rotate1)),
G_MTX_MODELVIEW|G_MTX_MUL|G_MTX_NOPUSH); */
/*
* Morph
*/
valist[0] = vface1;
weights[0] = t;
valist[1] = vface2;
weights[1] = 1.0 - t;
/* Two sets of key verticies, tricnt*3 verticies per set, alpha = 255 */
/* Texture coords come from vface1 */
morph(valist, weights, 2, &(generate->tvface1[0]), tricnt*3, 255, -ZDIST);
/*
* 2nd set of verticies, same except for different alpha and s,t
*/
a2 = 255*(1.0-t); /* alpha value */
for (i=0; i<tricnt*3; i++) {
generate->tvface2[i] = generate->tvface1[i];
generate->tvface2[i].v.tc[0] = vface2[i].v.tc[0] << 6;
generate->tvface2[i].v.tc[1] = vface2[i].v.tc[1] << 6;
generate->tvface2[i].v.cn[3] = a2;
} /* for i */
/* Pass 1 -- opaque */
gSPSetGeometryMode(glistp++, G_SHADE);
gDPPipeSync(glistp++);
gDPSetRenderMode(glistp++, G_RM_AA_ZB_OPA_SURF, G_RM_AA_ZB_OPA_SURF2);
gSPDisplayList(glistp++, OS_K0_TO_PHYSICAL(dlist1));
/* Pass 2 -- transparent */
gSPSetGeometryMode(glistp++, G_SHADE);
gDPPipeSync(glistp++);
gDPSetRenderMode(glistp++, G_RM_AA_XLU_SURF, G_RM_AA_XLU_SURF2);
gSPDisplayList(glistp++, OS_K0_TO_PHYSICAL(dlist2));
*glistpParam = glistp; /* Copy back from local var */
} /* drawframe */
PNM* MorphologicalOperator::transform()
{
int size = getParameter("size").toInt();
SE shape = (MorphologicalOperator::SE) getParameter("shape").toInt();
PNM* newImage = new PNM(image->width(), image->height(), QImage::Format_RGB32);
math::matrix<bool> se(size,size);
se = getSE(size,shape);
int radius = size/2;
if (image->format() == QImage::Format_Mono) {
}
else if (image->format() == QImage::Format_Indexed8) {
// Iterate over image space
for (int x=0; x<image->width(); x++) {
for (int y=0; y<image->height(); y++) {
math::matrix<double> window(size,size);
int a=0;
for (int i=(x-radius);i<(x+radius+1);i++) {
int b=0;
for (int j=(y-radius);j<(y+radius+1);j++) {
QRgb pixel = getPixel (i,j, RepeatEdge);
window(a,b) = qGray(pixel);
b++;
}
a++;
}
int v = morph(window, se);
newImage->setPixel(x,y, v);
}
}
}
else { //if (image->format() == QImage::Format_RGB32)
// Iterate over image space
for (int x=0; x<image->width(); x++) {
for (int y=0; y<image->height(); y++){
math::matrix<double> windowR(size,size);
math::matrix<double> windowG(size,size);
math::matrix<double> windowB(size,size);
int a=0;
for (int i=(x-radius);i<(x+radius+1);i++) {
int b=0;
for (int j=(y-radius);j<(y+radius+1);j++) {
QRgb pixel = getPixel (i,j, RepeatEdge);
windowR(a,b) = qRed(pixel);
windowG(a,b) = qGreen(pixel);
windowB(a,b) = qBlue(pixel);
b++;
}
a++;
}
int r = morph(windowR, se);
int g = morph(windowG, se);
int b = morph(windowB, se);
QColor newPixel = QColor(r,g,b);
newImage->setPixel(x,y, newPixel.rgb());
}
}
}
return newImage;
}
