//Connect randomly to one of the adjacent points in the spanning tree
void con_frnt()
{
int n, which, ydelt = 0, xdelt = 0;
int choice[4];
int cnt = 0, y, x;
//Choose a random frontier
n = rnd(frcnt);
ny = fr_y[n];
nx = fr_x[n];
fr_y[n] = fr_y[frcnt - 1];
fr_x[n] = fr_x[--frcnt];
//Count and collect the adjacent points we can connect to
if (maze_at({ nx, ny - 2 }) > 0) choice[cnt++] = 0;
if (maze_at({ nx, ny + 2 }) > 0) choice[cnt++] = 1;
if (maze_at({ nx - 2, ny }) > 0) choice[cnt++] = 2;
if (maze_at({ nx + 2, ny }) > 0) choice[cnt++] = 3;
//Choose one of the open places, connect to it and then the task is complete
which = choice[rnd(cnt)];
splat({ nx,ny });
switch (which)
{
case 0: which = 1; ydelt = -1; break;
case 1: which = 0; ydelt = 1; break;
case 2: which = 3; xdelt = -1; break;
case 3: which = 2; xdelt = 1; break;
}
y = ny + ydelt;
x = nx + xdelt;
if (inrange({ x,y })) splat({ x,y });
}
inline void splatFiltered(Vec2f pixel, Vec3f w)
{
if (_filter.isDirac()) {
return;
} else if (_filter.isBox()) {
splat(Vec2u(pixel), w);
} else {
float px = pixel.x() - 0.5f;
float py = pixel.y() - 0.5f;
uint32 minX = max(int(px + 1.0f - _filter.width()), 0);
uint32 maxX = min(int(px + _filter.width()), int(_w) - 1);
uint32 minY = max(int(py + 1.0f - _filter.width()), 0);
uint32 maxY = min(int(py + _filter.width()), int(_h) - 1);
// Maximum filter width is 2 pixels
float weightX[4], weightY[4];
for (uint32 x = minX; x <= maxX; ++x)
weightX[x - minX] = _filter.evalApproximate(x - px);
for (uint32 y = minY; y <= maxY; ++y)
weightY[y - minY] = _filter.evalApproximate(y - py);
for (uint32 y = minY; y <= maxY; ++y)
for (uint32 x = minX; x <= maxX; ++x)
splat(Vec2u(x, y), w*weightX[x - minX]*weightY[y - minY]);
}
}
static int
printtable(Paragraph *pp, MMIOT *f)
{
/* header, dashes, then lines of content */
Line *hdr, *dash, *body;
Istring align;
int start;
int hcols;
char *p;
if ( !(pp->text && pp->text->next && pp->text->next->next) )
return 0;
hdr = pp->text;
dash= hdr->next;
body= dash->next;
/* first figure out cell alignments */
CREATE(align);
for (p=T(dash->text), start=0; start < S(dash->text); ) {
char first, last;
int end;
last=first=0;
for (end=start ; (end < S(dash->text)) && p[end] != '|'; ++ end ) {
if ( !isspace(p[end]) ) {
if ( !first) first = p[end];
last = p[end];
}
}
EXPAND(align) = ( first == ':' ) ? (( last == ':') ? CENTER : LEFT)
: (( last == ':') ? RIGHT : 0 );
start = 1+end;
}
Qstring("<table>\n", f);
Qstring("<thead>\n", f);
hcols = splat(hdr, "th", align, 0, f);
Qstring("</thead>\n", f);
if ( hcols > S(align) )
S(align) = hcols;
else
while ( hcols > S(align) )
EXPAND(align) = 0;
Qstring("<tbody>\n", f);
for ( ; body; body = body->next)
splat(body, "td", align, 1, f);
Qstring("</tbody>\n", f);
Qstring("</table>\n", f);
DELETE(align);
return 1;
}
void SplatterSystem::spray( const QVector3D & source, float size )
{
if( size < 10.0f ) size = 10.0f;
if( size > 100.0f ) size = 100.0f;
int numToEmit = 0.5f * size;
if( numToEmit < 1 ) numToEmit = 1;
mParticleSystem->emitSpherical( source, numToEmit, 0.25f*size, 1.0f*size );
if( mSplatBelow && mTerrain->getHeightAboveGround( source ) < size*0.5f )
splat( source, size * RandomNumber::minMax( 0.2f, 0.3f ) );
int maxSecOffset = 0;
for( int i=0; i<mBurstSampleSources.size(); ++i )
{
if( !mBurstSampleSources[i]->isPlaying() )
{
maxSecOffset = i;
break;
}
if( mBurstSampleSources[i]->secOffset() > mBurstSampleSources[maxSecOffset]->secOffset() )
{
maxSecOffset = i;
}
}
mBurstSampleSources[maxSecOffset]->setPosition( source );
mBurstSampleSources[maxSecOffset]->rewind();
mBurstSampleSources[maxSecOffset]->setPitch( RandomNumber::minMax( 1.0f-mBurstPitchRange*0.5, 1.0+mBurstPitchRange*0.5 ) );
mBurstSampleSources[maxSecOffset]->play();
}
void draw_maze(struct Room *room)
{
int y, x;
int fy[MAXFRNT], fx[MAXFRNT];
int psgcnt;
Coord spos;
fr_y = fy;
fr_x = fx;
maxx = maxy = 0;
topy = room->m_ul_corner.y;
if (topy == 0) topy = ++room->m_ul_corner.y;
topx = room->m_ul_corner.x;
//Choose a random spot in the maze and initialize the frontier to be the immediate neighbors of this random spot.
y = topy;
x = topx;
splat({ x,y });
new_frontier({ x,y });
//While there are new frontiers, connect them to the path and possibly expand the frontier even more.
while (frcnt) {
con_frnt();
new_frontier({ nx,ny });
}
//According to the Grand Beeking, every maze should have a loop. Don't worry if you don't understand this.
room->m_size.x = maxx - room->m_ul_corner.x + 1;
room->m_size.y = maxy - room->m_ul_corner.y + 1;
do
{
static Coord ld[4] = { -1, 0, 0, 1, 1, 0, 0, -1 };
Coord *cp;
int sh;
rnd_pos(room, &spos);
for (psgcnt = 0, cp = ld, sh = 1; cp < &ld[4]; sh <<= 1, cp++)
{
y = cp->y + spos.y; x = cp->x + spos.x;
if (!offmap({ x,y }) && game->level().get_tile({ x, y }) == PASSAGE) psgcnt += sh;
}
} while (game->level().get_tile(spos) == PASSAGE || psgcnt % 5);
splat(spos);
}
void BrickDensityRegion::loadOceanData(string file, Vec3 vol_res, int iso_min, int iso_max) {
m_brickData = BrickGrid(vol_res.x(),vol_res.y(),vol_res.z());
SciDataParser parser = SciDataParser();
parser.parseFile(file);
vector<SciData> data = parser.getData();
Vec3 minLoc = parser.getMinLoc();
Vec3 maxLoc = parser.getMaxLoc();
Vec3 locDiff = maxLoc - minLoc;
printf("MIN: <%f, %f, %f>\n", minLoc.x(), minLoc.y(), minLoc.z());
printf("MAX: <%f, %f, %f>\n", maxLoc.x(), maxLoc.y(), maxLoc.z());
double minO2 = parser.getMinO2();
double maxO2 = parser.getMaxO2();
double O2diff = maxO2 - minO2;
printf("MIN: %f, MAX: %f\n", minO2, maxO2);
Vec3 tmpLoc;
double tmpO2;
SciData dPoint;
int end_x, end_y, end_z;
double end_density;
for( int i = 0; i < data.size(); i++ ) {
dPoint = data.at(i);
// Normalize location
tmpLoc = dPoint.getLocation();
tmpLoc = tmpLoc - minLoc;
tmpLoc.x( tmpLoc.x() / locDiff.x());
tmpLoc.y( tmpLoc.y() / locDiff.y());
tmpLoc.z( tmpLoc.z() / locDiff.z());
tmpO2 = dPoint.getO2Concenration();
tmpO2 -= minO2;
tmpO2 /= O2diff;
/*
printf("WRITING %d\n", tmpO2 * m_density_mult);
printf("AT LOCATION <%d, %d, %d>\n", (int)(tmpLoc.x() * vol_res.x()),
(int)(tmpLoc.y() * vol_res.y()),
(int)(tmpLoc.z() * vol_res.z()));
*/
end_x = (int)(tmpLoc.x() * vol_res.x());
end_y = (int)(tmpLoc.y() * vol_res.y());
end_z = (int)(tmpLoc.z() * vol_res.z());
end_density = tmpO2 * m_density_mult;
int splatVal;
if(tmpO2 < 0.4) {
splatVal = 0;
}else if(tmpO2 < 0.6) {
splatVal = 1;
}else if(tmpO2 < 0.9) {
splatVal = 2;
}else if(tmpO2 < 0.95) {
splatVal = 3;
}else{
splatVal = 4;
}
if(end_x > 1 && end_x < (vol_res.x() - 1)) {
if(end_y > 1 && end_y < (vol_res.y() - 1)) {
if(end_z > 1 && end_z < (vol_res.z() - 1)) {
splat(end_x,end_y,end_z, end_density, splatVal);
}
}
}
}
}
int main(int argc, char **argv)
{
if (argc < 6) print_usage(argv);
char *path = argv[1];
int start = atoi(argv[2]), end = atoi(argv[3]), i, *bkgc;
//IplImage *bkg = alignedImageFrom(mkname(path, 1), 8);
IplImage *bkg = alignedImageFrom(argv[4], 8);
int dim = plane_coeffs[0] + plane_coeffs[1] + plane_coeffs[2];
CvSize bsz = cvGetSize(bkg);
IplImage *d8 = alignedImageFrom(argv[5], 8);
//IplImage *d8 = alignedImageFrom(mkname(path, 1), 8);
int w = bsz.width - 8 + 1, h = bsz.height - 8 + 1, sz = w*h;
kd_tree kdt;
printf("cd: %s %d %d %s %s\n", path, start, end, argv[4], argv[5]);
init_g(bkg);
memset(&kdt, 0, sizeof(kd_tree));
/*
IplImage *b32 = cvCreateImage(bsz, IPL_DEPTH_32F, bkg->nChannels);
IplImage *i32 = cvCreateImage(bsz, IPL_DEPTH_32F, bkg->nChannels);
IplImage *d32 = cvCreateImage(bsz, IPL_DEPTH_32F, bkg->nChannels);
IplImage *diff= cvCreateImage(bsz, IPL_DEPTH_32F, bkg->nChannels);
cvXor(b32, b32, b32, NULL);
cvXor(d32, d32, d32, NULL);
cvConvertScale(bkg, b32, 1/255.0, 0);
for (i = 1; i < start; i++) {
IplImage *img = alignedImageFrom(mkname(path, i), 8);
cvConvertScale(img, i32, 1/256.0, 0);
cvAbsDiff(i32, b32, diff);
cvRunningAvg(diff, d32, 1.0/start, NULL);
cvRunningAvg(i32, b32, 1.0/start, NULL);
cvReleaseImage(&img);
cvShowImage("avg diff", d32);
cvWaitKey(1);
printf("i: %d\r", i);
}
cvConvertScale(b32, bkg, 255, 0);
cvReleaseImage(&b32);
cvReleaseImage(&i32);
if (argc >= 6) {
cvSaveImage(argv[4], bkg, 0);
cvConvertScale(d32, d8, 255, 0);
cvSaveImage(argv[5], d8, 0); // difference image
return 0;
}
*/
int *imgc = block_coeffs(d8, plane_coeffs);
IplImage *rev = splat(imgc, bsz, plane_coeffs);
free(imgc);
cvReleaseImage(&rev);
prop_coeffs(bkg, plane_coeffs, &bkgc);
kdt_new(&kdt, bkgc, sz, dim);
/*thread_ctx ctxs[3];
pthread_t thrs[sizeof(ctxs)/sizeof(thread_ctx)];
for (i = 0; i < (int)(sizeof(ctxs)/sizeof(thread_ctx)); i++) {
thread_ctx *ctx = &ctxs[i];
ctx->start = i+1;
ctx->end = end;
ctx->nb = sizeof(ctxs)/sizeof(thread_ctx);
ctx->path = path;
ctx->outfile = argc >= 7 ? argv[6] : NULL;
ctx->bkg = bkg;
ctx->diff = d8;
ctx->kdt = &kdt;
pthread_create(&thrs[i], NULL, run_thr, ctx);
}
for (i = 0; i < (int)(sizeof(ctxs)/sizeof(thread_ctx)); i++) {
pthread_join(thrs[i], NULL);
}
printf("all done!\n");*/
double t;
char outname[1024];
memset(outname, '\0', sizeof(outname));
for (i = start; i <= end; i++) {
IplImage *img = alignedImageFrom(mkname(path, i), 8);
double start = get_time();
if (argc >= 7) snprintf(outname, sizeof(outname), "%s/bin%06d.png", argv[6], i);
//process(&kdt, bkg, d8, img, outname);
//test(img);
cvShowImage("image", img);
t += (get_time() - start);
if ((cvWaitKey(1)&255)==27)break; // esc
cvReleaseImage(&img);
}
//free_g();
kdt_free(&kdt);
free(bkgc);
cvReleaseImage(&bkg);
cvReleaseImage(&d8);
return 0;
}
static void process(kd_tree *kdt, IplImage *bkg, IplImage *diff,
IplImage *img, char *outname)
{
//int *imgc = block_coeffs(img, plane_coeffs);
cvAbsDiff(img, bkg, diff_g);
int *imgc = block_coeffs(diff_g, plane_coeffs);
CvSize blksz = {(img->width/8)+7, (img->height/8)+7};
IplImage *xy = prop_match_complete(kdt, imgc, bkg, blksz);
IplImage *rev = splat(imgc, cvGetSize(img), plane_coeffs);
xy2blks_special(xy, diff, recon_g, 8);
cvAbsDiff(rev, recon_g, diff_g);
cvReleaseImage(&rev);
/*int *imgc;
prop_coeffs(diff_g, plane_coeffs, &imgc);
CvSize blksz = cvGetSize(bkg);
IplImage *xy = prop_match_complete(kdt, imgc, bkg, blksz);
xy2img(xy, diff, recon_g);
cvAbsDiff(diff_g, recon_g, diff_g);*/
//cvShowImage("diff_g before mul", diff_g);
//cvAbsDiff(diff_g, diff, diff_g);
//cvMul(diff_g, idiff, diff_g, 1);
cvCvtColor(diff_g, gray_g, CV_BGR2GRAY);
// full pixel dc
//IplImage *dc = make_dc(gray_g);
IplImage *mask = cvCreateImage(cvGetSize(img), IPL_DEPTH_8U, 1);
IplImage *dc_f = cvCreateImage(cvGetSize(img), IPL_DEPTH_32F, 1);
int *graydc = gck_calc_2d((uint8_t*)gray_g->imageData, img->width, img->height, KERNS, 1);
IplImage *dc = cvCreateImageHeader(cvGetSize(img), IPL_DEPTH_32S, 1);
int step = img->width + KERNS - 1;
cvSetData(dc, graydc, step*sizeof(int));
cvConvertScale(dc, dc_f, 1/255.0, 0);
cvThreshold(gray_g, mask, 25, 255.0, CV_THRESH_BINARY);
mask->width = orig_w;
mask->height = orig_h;
if (*outname) cvSaveImage(outname, mask, 0);
/*double min = 0, max = 0;
cvMinMaxLoc(dc, &min, &max, NULL, NULL, NULL);
printf("min: %3f max: %3f\n", min, max);
CvScalar scalar = cvRealScalar(-min);
cvAddS(dc, scalar, dc_f, NULL);
cvConvertScale(dc_f, dc_f, 1.0/(max - min), 0);*/
// macroblock based counts
//cvAdaptiveThreshold(gray_g, mask_g, 255, CV_ADAPTIVE_THRESH_GAUSSIAN_C, CV_THRESH_BINARY, 3, 0);
//cvSmooth(mask_g, mask_g, CV_GAUSSIAN, 9, 9, 0, 0);
//cvSmooth(diff_g, diff_g, CV_GAUSSIAN, 5, 5, 0, 0);
//cvLaplace(diff_g, lap_g, 3);
//IplImage *xy = prop_match(bkg, img);
//xy2img(xy, bkg, recon_g);
//cvAbsDiff(recon_g, img, diff_g);
/*cvShowImage("recon", recon_g);
//cvShowImage("diff", rev);
cvShowImage("diff_g", diff_g);
cvShowImage("img", img);
cvShowImage("gray", gray_g);
cvShowImage("dc float", dc_f);
cvShowImage("mask", mask);
cvShowImage("dc", dc);*/
free(imgc);
cvReleaseImage(&xy);
cvReleaseImageHeader(&dc);
free(graydc);
cvReleaseImage(&mask);
cvReleaseImage(&dc_f);
}
int main(int argc, const char *argv[])
{
ALLEGRO_EVENT event;
ALLEGRO_KEYBOARD_STATE kst;
bool blend;
if (!al_init()) {
abort_example("Could not init Allegro.\n");
return 1;
}
al_init_primitives_addon();
al_install_keyboard();
al_install_mouse();
display = al_create_display(W, H);
if (!display) {
abort_example("Error creating display\n");
return 1;
}
black = al_map_rgb_f(0.0, 0.0, 0.0);
white = al_map_rgb_f(1.0, 1.0, 1.0);
background = al_map_rgb_f(0.5, 0.5, 0.6);
if (argc > 1 && 0 == strcmp(argv[1], "--memory-bitmap")) {
al_set_new_bitmap_flags(ALLEGRO_MEMORY_BITMAP);
}
dbuf = al_create_bitmap(W, H);
if (!dbuf) {
abort_example("Error creating double buffer\n");
return 1;
}
al_set_target_bitmap(dbuf);
al_clear_to_color(background);
draw_clip_rect();
flip();
queue = al_create_event_queue();
al_register_event_source(queue, al_get_keyboard_event_source());
al_register_event_source(queue, al_get_mouse_event_source());
while (true) {
al_wait_for_event(queue, &event);
if (event.type == ALLEGRO_EVENT_MOUSE_BUTTON_DOWN) {
al_get_keyboard_state(&kst);
blend = al_key_down(&kst, ALLEGRO_KEY_LSHIFT) ||
al_key_down(&kst, ALLEGRO_KEY_RSHIFT);
if (event.mouse.button == 1) {
plonk(event.mouse.x, event.mouse.y, blend);
} else {
splat(event.mouse.x, event.mouse.y, blend);
}
}
else if (event.type == ALLEGRO_EVENT_DISPLAY_SWITCH_OUT) {
last_x = last_y = -1;
}
else if (event.type == ALLEGRO_EVENT_KEY_DOWN &&
event.keyboard.keycode == ALLEGRO_KEY_ESCAPE)
{
break;
}
}
al_destroy_event_queue(queue);
al_destroy_bitmap(dbuf);
return 0;
}
void FFTMagnitudeSelectionUGenInternal::processBlock(bool& shouldDelete, const unsigned int blockID, const int /*channel*/) throw()
{
const int blockSize = uGenOutput.getBlockSize();
int numSamplesToProcess = blockSize;
float* inputSamples = inputs[Input].processBlock(shouldDelete, blockID, 0);
float* bufferSamples = inputBuffer.getData();
// get output pointers
for(int channel = 0; channel < bins.length(); channel++)
{
outputSampleData[channel] = proxies[channel]->getSampleData();
}
while(numSamplesToProcess > 0)
{
int bufferSamplesToProcess = fftSize - bufferIndex;
if(bufferSamplesToProcess > numSamplesToProcess)
{
memcpy(bufferSamples + bufferIndex, inputSamples, numSamplesToProcess * sizeof(float));
bufferIndex += numSamplesToProcess;
inputSamples += numSamplesToProcess;
numSamplesToProcess = 0;
}
else
{
numSamplesToProcess -= bufferSamplesToProcess;
memcpy(bufferSamples + bufferIndex, inputSamples, bufferSamplesToProcess * sizeof(float));
bufferIndex += bufferSamplesToProcess;
inputSamples += bufferSamplesToProcess;
bufferSamplesToProcess = 0;
fftEngine.fft(outputBuffer, inputBuffer, true);
magnitudes = fftEngine.rawToMagnitude(outputBuffer, 0, maxNumBins);
FloatArray floatMag = magnitudes.toArray<float>(0).at(bins);
magnitudes = Buffer(floatMag);
if(overlap_ > 1)
{
memcpy(inputBuffer.getData(), inputBuffer.getData() + hopSize, overlapSize * sizeof(float));
bufferIndex = fftSize - hopSize;
}
else
{
bufferIndex = 0;
}
}
const int outputSamplesToProcess = hopSize < blockSize ? hopSize : blockSize;
for(int channel = 0; channel < bins.length(); channel++)
{
float magnitude = magnitudes.getSampleUnchecked(channel);
splat(outputSampleData[channel], magnitude, outputSamplesToProcess);
outputSampleData[channel] += outputSamplesToProcess;
}
}
}
