WarpList Warp::readSettings( const DataSourceRef &source ) { XmlTree doc; WarpList warps; // try to load the specified xml file try { doc = XmlTree( source ); } catch( ... ) { return warps; } // check if this is a valid file bool isWarp = doc.hasChild( "warpconfig" ); if( !isWarp ) return warps; // if( isWarp ) { // get first profile XmlTree profileXml = doc.getChild( "warpconfig/profile" ); // iterate maps for( XmlTree::ConstIter child = profileXml.begin( "map" ); child != profileXml.end(); ++child ) { XmlTree warpXml = child->getChild( "warp" ); // create warp of the correct type std::string method = warpXml.getAttributeValue<std::string>( "method", "unknown" ); if( method == "bilinear" ) { WarpBilinearRef warp( new WarpBilinear() ); warp->fromXml( warpXml ); warps.push_back( warp ); } else if( method == "perspective" ) { WarpPerspectiveRef warp( new WarpPerspective() ); warp->fromXml( warpXml ); warps.push_back( warp ); } else if( method == "perspectivebilinear" ) { WarpPerspectiveBilinearRef warp( new WarpPerspectiveBilinear() ); warp->fromXml( warpXml ); warps.push_back( warp ); } } } return warps; }
int main (int argc, char *argv[]) { unsigned char *rawpic = NULL; unsigned char *warpedpic = NULL; size_t width, height; int num_components, color_space; /* Get raw data */ rawpic = read_jpeg ("shrek_cat_eyes.jpg", &width, &height, &num_components, &color_space); if (!rawpic) goto out; warpedpic = calloc(1, width*height*num_components); if (!warpedpic) goto out; /* do some processing here */ warp(rawpic, warpedpic, width, height, num_components); //thresholding(rawpic, warpedpic, width, height, num_components); //shift(rawpic, warpedpic, width, height, num_components); /* write it back as jpeg */ write_jpeg ("out.jpg", warpedpic, width, height, num_components, color_space); printf("Done :)\n"); out: if (rawpic) free(rawpic); if (warpedpic) free(warpedpic); return 0; }
void Level::createTiledObjects() { //Create Warps //Read tiled info: lua level script, warp destiny, etc. //The collider checks when there is a interaction with the warp and triggers the teleportation for (unsigned int i = 0; i < map->object_group.warp_rects.size(); ++i) { std::unique_ptr<Warp> warp(new Warp(sf::RectangleShape(sf::Vector2f(map->object_group.warp_rects[i].width * map->getScale().x, map->object_group.warp_rects[i].height * map->getScale().y)))); float x_corrected = map->object_group.warp_rects[i].left * map->getScale().x ; float y_corrected = map->object_group.warp_rects[i].top * map->getScale().y ; float x_destiny_corrected = map->object_group.warp_destinies[i].x * 2.f ; float y_destiny_corrected = map->object_group.warp_destinies[i].y * 2.f; std::string level_script_name = map->object_group.warp_level_scripts[i]; int first_animation = map->object_group.warp_directions[i]; warp->setPosition(sf::Vector2f(x_corrected, y_corrected)); warp->setDestiny(sf::Vector2f(x_destiny_corrected, y_destiny_corrected)); warp->setLevelScriptName(level_script_name); warp->setFirstAnimation(first_animation); node_vector.push_back(warp.get()); layers[0]->addChild(std::move(warp)); } }
void affine::showWarp() { warp(mtx,&mtx_warp,ui->horizontalSlider_4->value()); IplImage* img=new IplImage(mtx_warp); QImage qmtx=IplImage2QImage(img); ui->label->clear(); ui->label->setPixmap(QPixmap::fromImage(qmtx)); repaint(); }
void moving(ground& earth, square& another) { move_left(); move_right(); gravity(earth); warp(another); collision_check(another); set_square_posit(); move_shots(); }
void TimeTrack::testMe() { GetEnvelope()->SetDefaultValue(0.5); GetEnvelope()->Flatten(0.0); GetEnvelope()->Insert( 0.0, 0.0 ); GetEnvelope()->Insert( 5.0, 1.0 ); GetEnvelope()->Insert( 10.0, 0.0 ); double reqt0 = 10.0 - .1; double reqt1 = 10.0 + .1; double t0 = warp( reqt0 ); double t1 = warp( reqt1 ); if( t0 > t1 ) { printf( "TimeTrack: Warping reverses an interval! [%.2f,%.2f] -> [%.2f,%.2f]\n", reqt0, reqt1, t0, t1 ); } }
/* * dowarp() is used in a struct cvntab to call warp(). Since it is always ram * or move, fl is never < 0, so ask the user for course and distance, then pass * that to warp(). */ void dowarp(int fl) { int c; double d; if (getcodi(&c, &d)) return; warp(fl, c, d); }
void SphereCapLight::getIrradianceSamples(Vec3f point, const Scene* scene, vector<LightRay>& result, float time) { // Calculate cap heigth float connectionSq = (point - location).length2(); float connection = sqrt(connectionSq); float tangentSq = connectionSq - radius*radius; float heightToPoint = tangentSq / connection; auto sphereWarping = std::unique_ptr<Warping>(new UniformSphereCapWarping((radius - (connection-heightToPoint)) / radius)); // Calculate rotation Vec3f dir = (point - location).normalized(); Mat44f rotation = Mat44f(1); rotation.rotateTo(Vec3f(0,0,1), dir); // Draw new samples std::vector<Vec2f> drawnPoints(nSamples); randomSampler->generateSamples(nSamplesSqrt, drawnPoints); Color3f sum = Color3f(0); for (unsigned int i = 0; i < nSamples; i++) { // Warp and rotate samples if (point.x < 0 && point.y > 0) int a = 0; Vec3f warpedPoint = rotation * sphereWarping->warp(drawnPoints[i]); Vec3f spherePoint = warpedPoint * radius; Vec3f difference = point - (spherePoint + location); float distance = difference.length(); LightRay lr; Ray r; lr.direction = difference / distance; r.d = lr.direction; r.o = spherePoint + location; r.tMax = distance - r.tMin; r.time = time; // Check for intersection for (unsigned int k = 0; k < scene->shapes.size(); k++) { scene->shapes[k]->intersect(&r); } //if ray hit something then it does not contribute if (r.hit.shape == 0) { float pdf = sphereWarping->pdf(drawnPoints[i]); //lr.radiance = power * dot(lr.direction, warpedPoint) / (sphereWarping->pdf(drawnPoints[i]) * 4*PI * pow(distance+radius, 2)); float a = 1/(sphereWarping->pdf(drawnPoints[i]) * 4*PI); lr.radiance = radiance * 4 * pow(radius,2) * std::max(0.f,dot(lr.direction, warpedPoint)) / (sphereWarping->pdf(drawnPoints[i]) * 4*PI * pow(distance, 2)); } else { lr.radiance = Color3f(0); } result.push_back(lr); } }
bool Asteroid::onCollision(GameObjectType got){ switch(got){ case GameObjectType::Boundary: warp(2.0); return false; case GameObjectType::Asteroid: return true; default: split(); World::getWorld().lock()->deregisterGameObject(this); return false; } }
void GameState::enqueueWarp(Character *ptr, MapComposite *m, int x, int y) { // When the player has just disconnected, better not wait for the pointer // to become invalid. if (!ptr->isConnected()) { warp(ptr, m, x, y); return; } DelayedEvent e = { EVENT_WARP, x, y, m }; enqueueEvent(ptr, e); }
Mat StereoImageWarper::warpImage(StereoImage* img, Size &destSize, Mesh &deformedLeft, Mesh &deformedRight, Mesh &linearScaledLeft, Mesh &linearScaledRight) { cout << "\nStart stereo image warping" << endl; newSize = destSize; Mat src = img->getBoth_eye(); Size destLeftSize(newSize.width / 2, newSize.height); Mat destLeft = Mat::zeros(destLeftSize, CV_32FC3); Mat destRight = Mat::zeros(destLeftSize, CV_32FC3); Mat linearLeft, linearRight; Mat leftEye = img->getLeft_eye(); Mat rightEye = img->getRight_eye(); // scale down left and right for reference during the image warping resize(leftEye, linearLeft, destLeftSize); resize(rightEye, linearRight, destLeftSize); linearLeft.convertTo(linearLeft, CV_32FC3); linearRight.convertTo(linearRight, CV_32FC3); // warp left and right view warp(linearScaledLeft, deformedLeft, linearLeft, destLeft); warp(linearScaledRight, deformedRight, linearRight, destRight); destLeft.convertTo(destLeft, src.type()); destRight.convertTo(destRight, src.type()); // merge left and right warped image Mat dest = Mat::zeros(Size(destLeft.size().width * 2, destLeft.size().height), src.type()); Mat roi = dest(Rect(0, 0, destLeft.size().width, destLeft.size().height)); destLeft.copyTo(roi); roi = dest(Rect(destLeft.size().width, 0, destLeft.size().width, destLeft.size().height)); destRight.copyTo(roi); return dest; }
cv::Mat Transform::reconstruct(cv::Mat &src, unsigned int s) { cv::Mat warped = warp(src, s); // color scale //*/ std::vector<cv::Mat> planes; split(warped, planes); for(unsigned int i=0; i<planes.size(); i++) { planes[i] *= colorScale_.val[i]; } merge(planes, warped); //*/ return warped; }
//! from json void WarpPerspectiveBilinear::fromJson(const JsonTree &json) { Warp::fromJson(json); if (json.hasChild("warp")) { JsonTree warp(json.getChild("warp")); // get corners JsonTree corners(warp.getChild("corners")); for (size_t i = 0; i < corners.getNumChildren(); i++) { JsonTree child = corners.getChild(i); float x = (child.hasChild("x")) ? child.getValueForKey<float>("x") : 0.0f; float y = (child.hasChild("y")) ? child.getValueForKey<float>("y") : 0.0f; mWarp->setControlPoint(i, vec2(x, y)); CI_LOG_V("corner:" + toString(x) + " " + toString(y)); } } }
void pause(int t) { int s; Alt alts[NALT+1]; alts[TIMER].c = timerc; alts[TIMER].v = nil; alts[TIMER].op = CHANRCV; alts[SUSPEND].c = suspc; alts[SUSPEND].v = &s; alts[SUSPEND].op = CHANRCV; alts[RESHAPE].c = mousectl->resizec; alts[RESHAPE].v = nil; alts[RESHAPE].op = CHANRCV; // avoid hanging up those writing ong mousec and kbdc // so just accept it all and keep mouse up-to-date alts[MOUSE].c = mousec; alts[MOUSE].v = &mouse; alts[MOUSE].op = CHANRCV; alts[KBD].c = kbdc; alts[KBD].v = nil; alts[KBD].op = CHANRCV; alts[NALT].op = CHANEND; flushimage(display, 1); for(;;) switch(alt(alts)) { case SUSPEND: if (!suspended && s) { suspend(1); } else if (suspended && !s) { suspend(0); lastmx = warp(mouse.xy, lastmx); } break; case TIMER: if(suspended) break; if((t -= tsleep) < 0) return; break; case RESHAPE: redraw(1); break; } }
int drop(int f) { if(f){ score(5L*(rboard.max.y-pos.y)/pcsz); do; while(movepiece()); } fusst = 0; rest(); if(pos.y==rboard.min.y && !horiz()) return 1; horiz(); setpiece(0); pause(1500); choosepiece(); lastmx = warp(mouse.xy, lastmx); return 0; }
void GameState::enqueueWarp(Entity *ptr, MapComposite *map, const Point &point) { // When the player has just disconnected, better not wait for the pointer // to become invalid. if (!ptr->getComponent<CharacterComponent>()->isConnected()) { warp(ptr, map, point); return; } DelayedEvent event; event.type = EVENT_WARP; event.point = point; event.map = map; enqueueEvent(ptr, event); }
// Fix some edge crossings by warping vertices if it's admissible static void warp_vertices(const float threshold, TetMesh& mesh, std::vector<float>& vphi) { assert(threshold>=0 && threshold<=0.5); std::vector<float> warp(mesh.vSize(), FLT_MAX); std::vector<int> warp_nbr(mesh.vSize(), -1); std::vector<Vec3f> d(mesh.vSize(), Vec3f(0,0,0)); // it's wasteful to iterate through tets just to look at edges; oh well for (size_t t=0; t<mesh.tSize(); ++t) { for (int u=0; u<3; ++u) { int i = mesh.T(t)[u]; for (int v=u+1; v<4; ++v) { int j = mesh.T(t)[v]; if ((vphi[i]<0 && vphi[j]>0) || (vphi[i]>0 && vphi[j]<0)) { float alpha = vphi[i]/(vphi[i]-vphi[j]); if (alpha < threshold) { // warp i? float d2 = alpha*dist2(mesh.V(i), mesh.V(j)); if (d2 < warp[i]) { warp[i] = d2; warp_nbr[i] = j; d[i] = alpha*(mesh.V(j)-mesh.V(i)); } } else if (alpha > 1-threshold) { // warp j? float d2 = (1-alpha)*dist2(mesh.V(i), mesh.V(j)); if (d2 < warp[j]) { warp[j] = d2; warp_nbr[j] = i; d[j] = (1-alpha)*(mesh.V(i)-mesh.V(j)); } } } } } } // do the warps (also wasteful to loop over all vertices; oh well) for (size_t i=0; i<mesh.vSize(); ++i) if(warp_nbr[i]>=0) { mesh.V(i) += d[i]; vphi[i] = 0; } }
autover() { double dist; register int course; printf("\07RED ALERT: The %s is in a supernova quadrant\n", Ship.shipname); printf("*** Emergency override attempts to hurl %s to safety\n", Ship.shipname); /* let's get our ass out of here */ Ship.warp = 6.0 + 2.0 * franf(); Ship.warp2 = Ship.warp * Ship.warp; Ship.warp3 = Ship.warp2 * Ship.warp; dist = 0.75 * Ship.energy / (Ship.warp3 * (Ship.shldup + 1)); if (dist > 1.4142) dist = 1.4142; course = ranf(360); Etc.nkling = -1; Ship.cond = RED; warp(-1, course, dist); attack(0); }
float bassin(vec3 p) { //sol avec un trou float v = cylindre(p, vec3(0,-5,0), vec3(0,-3,0), 10.0,1.0,1.0); v = Difference(v, cylindre(p, vec3(0,-4,0), vec3(0,-3,0), 5.0,1.0,1.0)); //vague dans le trou v = Blend(v, vague(warp(vec3(p)), vec3(0,-3.5,0), 5.5, 0.15, 0.15,1.0,1.0)); //piliers v = Union(v, colonne(p, vec3(8,-1.8,0), vec3(8,3.0,0), 0.5, 1.0, 0.6)); v = Union(v, colonne(p, vec3(0,-1.8,8), vec3(0,3.0,8), 0.5, 1.0, 0.6)); v = Union(v, colonne(p, vec3(-8,-1.8,0), vec3(-8,3.0,0), 0.5, 1.0, 0.6)); v = Union(v, colonne(p, vec3(0,-1.8,-8), vec3(0,3.0,-8), 0.5, 1.0, 0.6)); //toit v = Union(v, cylindre(p, vec3(0,4.2,0), vec3(0,5,0), 10.0,1.0,1.0)); return v; }
void MeshWarpWidget::mouseReleaseEvent(QMouseEvent *event) { if (m_has_active_cp) { if (m_show_warped) { m_img = warp(m_orig_img, m_orig_mesh, m_mesh); } update(); } else if (m_panning) { m_vect_x += (event->x() - m_origin_x); m_vect_y += (event->y() - m_origin_y); m_panning = false; DBGM("Panning DISabled"); } return QWidget::mouseReleaseEvent(event); }
//! to json JsonTree WarpPerspectiveBilinear::toJson() const { JsonTree json = WarpBilinear::toJson(); if (json.hasChild("warp")) { JsonTree warp(json.getChild("warp")); // set corners JsonTree corners = JsonTree::makeArray("corners"); for (unsigned i = 0; i < 4; ++i) { vec2 corner = mWarp->getControlPoint(i); JsonTree cr; cr.addChild(ci::JsonTree("corner", i)); cr.addChild(ci::JsonTree("x", corner.x)); cr.addChild(ci::JsonTree("y", corner.y)); corners.pushBack(cr); } warp.pushBack(corners); json.pushBack(warp); } return json; }
int main (int argc, char *argv[]) { struct timeval t1; struct warpparams p={{{0},0},0}; /* Set the starting time.*/ time(&p.rawtime); gettimeofday(&t1, NULL); /* Read the input parameters. */ ui_read_check_inputs_setup(argc, argv, &p); /* Run Warp */ warp(&p); /* Free all non-freed allocations. */ ui_free_report(&p, &t1); /* Return successfully.*/ return EXIT_SUCCESS; }
static void test_texture3d (ustring filename) { std::cerr << "Testing 3d texture " << filename << ", output = " << output_filename << "\n"; const int nchannels = 4; ImageSpec outspec (output_xres, output_yres, nchannels, TypeDesc::HALF); ImageBuf image (output_filename, outspec); ImageBufAlgo::zero (image); Imath::M33f scale; scale.scale (Imath::V2f (0.5, 0.5)); Imath::M33f rot; rot.rotate (radians(30.0f)); Imath::M33f trans; trans.translate (Imath::V2f (0.35f, 0.15f)); Imath::M33f xform = scale * rot * trans; xform.invert(); TextureOptions opt; opt.sblur = blur; opt.tblur = blur; opt.rblur = blur; opt.swidth = width; opt.twidth = width; opt.rwidth = width; opt.nchannels = nchannels; float localfill = (fill >= 0 ? fill : 0.0f); opt.fill = localfill; if (missing[0] >= 0) opt.missingcolor.init ((float *)&missing, 0); opt.swrap = opt.twrap = opt.rwrap = TextureOptions::WrapPeriodic; int shadepoints = blocksize*blocksize; Imath::V3f *P = ALLOCA (Imath::V3f, shadepoints); Runflag *runflags = ALLOCA (Runflag, shadepoints); Imath::V3f *dPdx = ALLOCA (Imath::V3f, shadepoints); Imath::V3f *dPdy = ALLOCA (Imath::V3f, shadepoints); Imath::V3f *dPdz = ALLOCA (Imath::V3f, shadepoints); float *result = ALLOCA (float, shadepoints*nchannels); for (int iter = 0; iter < iters; ++iter) { // Iterate over blocks // Trick: switch to second texture, if given, for second iteration if (iter && filenames.size() > 1) filename = ustring (filenames[1]); for (int by = 0; by < output_yres; by+=blocksize) { for (int bx = 0; bx < output_xres; bx+=blocksize) { // Process pixels within a block. First save the texture warp // (s,t) and derivatives into SIMD vectors. int idx = 0; for (int y = by; y < by+blocksize; ++y) { for (int x = bx; x < bx+blocksize; ++x) { if (x < output_xres && y < output_yres) { if (nowarp) { P[idx][0] = (float)x/output_xres * sscale; P[idx][1] = (float)y/output_yres * tscale; P[idx][2] = 0.5f * sscale; P[idx] += offset; dPdx[idx][0] = 1.0f/output_xres * sscale; dPdx[idx][1] = 0; dPdx[idx][2] = 0; dPdy[idx][0] = 0; dPdy[idx][1] = 1.0f/output_yres * tscale; dPdy[idx][2] = 0; dPdz[idx].setValue (0,0,0); } else { Imath::V3f coord = warp ((float)x/output_xres, (float)y/output_yres, 0.5, xform); coord.x *= sscale; coord.y *= tscale; coord += offset; Imath::V3f coordx = warp ((float)(x+1)/output_xres, (float)y/output_yres, 0.5, xform); coordx.x *= sscale; coordx.y *= tscale; coordx += offset; Imath::V3f coordy = warp ((float)x/output_xres, (float)(y+1)/output_yres, 0.5, xform); coordy.x *= sscale; coordy.y *= tscale; coordy += offset; P[idx] = coord; dPdx[idx] = coordx - coord; dPdy[idx] = coordy - coord; dPdz[idx].setValue (0,0,0); } runflags[idx] = RunFlagOn; } else { runflags[idx] = RunFlagOff; } ++idx; } } // Call the texture system to do the filtering. bool ok = texsys->texture3d (filename, opt, runflags, 0, shadepoints, Varying(P), Varying(dPdx), Varying(dPdy), Varying(dPdz), result); if (! ok) { std::string e = texsys->geterror (); if (! e.empty()) std::cerr << "ERROR: " << e << "\n"; } for (int i = 0; i < shadepoints*nchannels; ++i) result[i] *= scalefactor; // Save filtered pixels back to the image. idx = 0; for (int y = by; y < by+blocksize; ++y) { for (int x = bx; x < bx+blocksize; ++x) { if (runflags[idx]) { image.setpixel (x, y, result + idx*nchannels); } ++idx; } } } } } if (! image.save ()) std::cerr << "Error writing " << output_filename << " : " << image.geterror() << "\n"; }
void GameState::update(int tick) { currentTick = tick; #ifndef NDEBUG dbgLockObjects = true; #endif ScriptManager::currentState()->update(); // Update game state (update AI, etc.) const MapManager::Maps &maps = MapManager::getMaps(); for (MapManager::Maps::const_iterator m = maps.begin(), m_end = maps.end(); m != m_end; ++m) { MapComposite *map = m->second; if (!map->isActive()) continue; map->update(); for (CharacterIterator p(map->getWholeMapIterator()); p; ++p) { informPlayer(map, *p); } for (ActorIterator it(map->getWholeMapIterator()); it; ++it) { Actor *a = *it; a->clearUpdateFlags(); if (a->canFight()) { static_cast< Being * >(a)->clearHitsTaken(); } } } # ifndef NDEBUG dbgLockObjects = false; # endif // Take care of events that were delayed because of their side effects. for (DelayedEvents::iterator it = delayedEvents.begin(), it_end = delayedEvents.end(); it != it_end; ++it) { const DelayedEvent &e = it->second; Actor *o = it->first; switch (e.type) { case EVENT_REMOVE: remove(o); if (o->getType() == OBJECT_CHARACTER) { Character *ch = static_cast< Character * >(o); ch->disconnected(); gameHandler->kill(ch); } delete o; break; case EVENT_INSERT: insertOrDelete(o); break; case EVENT_WARP: assert(o->getType() == OBJECT_CHARACTER); warp(static_cast< Character * >(o), e.map, e.x, e.y); break; } } delayedEvents.clear(); }
int main(int argc, char* argv[]) { initscr(); scrollok(stdscr, TRUE); wprintw(stdscr, "Welcome to Scripted ver. %d.%d for the Brave Quest engine.\nCopyright 2012 Mad Science Inc.\nPlease do not redistrubute.\n",scriptedvernum,scriptedvernum2); stufffilename(); if(loadscript(filename) == 1) { wprintw(stdscr, "File not Found. Would you like to make a new file?\n"); if(bie() == 'y') { cleanfilebuff(); if(savescript(filename) == 1) { wprintw(stdscr, "Your disk sucks.\n"); bi(); return 1; } } else { wprintw(stdscr, "Goodbye.\n"); endwin(); return 1; } } currlinenum = linenum; menu(); wprintw(stdscr, "Press escape to go to the save menu\n"); for(;;) { wprintw(stdscr, "q= give, w= take, e= say, r= flag, t= move, y= battle, u= check flag, i= check item, o= party add, p= party remove, [ = check character\n"); wprintw(stdscr, "a= warp, s= check experience, d= give experience, f= make experience, g= exec script, h= screen effect, j= user input, k= goline, l= make health\n"); wprintw(stdscr, "b= check stat, n= make stat, m= blank, ,= show line, .= change line.\n"); input[0] = bie(); if(input[0] == 27) menu(); if(input[0] == 'q') give(); if(input[0] == 'w') take(); if(input[0] == 'e') say(); if(input[0] == 'r') flag(); if(input[0] == 't') mmove(); if(input[0] == 'y') battle(); if(input[0] == 'u') checkflag(); if(input[0] == 'i') checkitem(); if(input[0] == 'o') partyadd(); if(input[0] == 'p') partyrm(); if(input[0] == '[') checkparty(); if(input[0] == 'a') warp(); if(input[0] == 's') checkexp(); if(input[0] == 'd') giveexp(); if(input[0] == 'f') makeexp(); if(input[0] == 'g') execscript(); if(input[0] == 'h') screeneffect(); if(input[0] == 'j') userinput(); if(input[0] == 'k') goline(); if(input[0] == 'l') makehealth(); if(input[0] == 'z') teachspell(); if(input[0] == 'x') unlearnspell(); if(input[0] == 'b') checkstat(); if(input[0] == 'n') makestat(); if(input[0] == 'm') blank(); if(input[0] == ',') showline(); if(input[0] == '.') changeline(); if(currlinenum > linenum) linenum = currlinenum; } return 0; };
static void frqtr2(double *c1, int m1, double *c2, int m2, int fftsz, double a, double t) { int i, j; double w, b, *ww, *f, *tc2, *re, *im, *pf, *pk, *next; int size_k, size_f, fftsz2; static double *k = NULL; static int size4, flag_k = 1; b = M_2PI / (double) fftsz; size_k = (m2 + 1) * (m1 + 1); if (k == NULL) { flag_k = 0; size4 = size_k; k = dgetmem(size4); } else if (size_k != size4) { free(k); flag_k = 0; size4 = size_k; k = dgetmem(size4); } /*------- if "k" is not defined ----------*/ if (flag_k == 0) { ww = dgetmem(fftsz); for (j = 0, w = 0.0; j < fftsz; j++, w += b) ww[j] = warp(w, a, t); fftsz2 = fftsz + fftsz; /* size of (re + im) */ size_f = (m2 + 1) * fftsz2; /* size of array "f" */ f = dgetmem(size_f); for (i = 0, re = f, im = f + fftsz; i <= m2; i++) { for (j = 0; j < fftsz; j++) *(re++) = cos(ww[j] * i); for (j = 0; j < fftsz; j++) *(im++) = -sin(ww[j] * i); re -= fftsz; im -= fftsz; ifft(re, im, fftsz); for (j = 1; j <= m1; j++) re[j] += re[fftsz - j]; re += fftsz2; im += fftsz2; } free(ww); /*------- copy "f" to "k" ----------*/ for (i = 0, next = f, pf = f, pk = k; i <= m2; i++) { for (j = 0; j <= m1; j++) *(pk++) = *(pf++); next += fftsz2; pf = next; } free(f); flag_k = 1; } tc2 = dgetmem(m2 + 1); /* tmp of c2 */ for (i = 0, pk = k; i <= m2; i++) for (j = 0, tc2[i] = 0.0; j <= m1; j++) tc2[i] += *(pk++) * c1[j]; movem(tc2, c2, sizeof(*c2), m2 + 1); free(tc2); return; }
static void ifreqt2(double *c1, int m1, double *c2, int m2, int fftsz, double a, double t) { int i, j; double w, b, *ww, *f, *re, *im, *pl, *pr, *plnxt, *prnxt, *pf, *ph, *next; int size_h, size_f, fftsz2, m12, m11; static double *h = NULL; static int size3, flag_h = 1; b = M_2PI / (double) fftsz; size_h = (m2 + 1) * (m1 + 1); if (h == NULL) { flag_h = 0; size3 = size_h; h = dgetmem(size3); } else if (size_h != size3) { free(h); flag_h = 0; size3 = size_h; h = dgetmem(size3); } /*------- if "h" is not defined ----------*/ if (flag_h == 0) { ww = dgetmem(fftsz); for (j = 0, w = 0.0; j < fftsz; j++, w += b) ww[j] = warp(w, a, t); fftsz2 = fftsz + fftsz; /* size of (re + im) */ m12 = m1 + m1 + 1; size_f = m12 * fftsz2; /* size of array "f" */ f = dgetmem(size_f); for (i = -m1, re = f, im = f + fftsz; i <= m1; i++) { for (j = 0; j < fftsz; j++) *(re++) = cos(ww[j] * i); for (j = 0; j < fftsz; j++) *(im++) = -sin(ww[j] * i); re -= fftsz; im -= fftsz; ifft(re, im, fftsz); re += fftsz2; im += fftsz2; } free(ww); /*------- b'(n,m)=b(n,m)+b(n,-m) ----------*/ pl = f; pr = f + (m12 - 1) * fftsz2; for (i = 0, plnxt = pl, prnxt = pr; i < m1; i++) { plnxt += fftsz2; prnxt -= fftsz2; for (j = 0; j <= m2; j++) *(pr++) += *(pl++); pl = plnxt; pr = prnxt; } /*------- copy "f" to "h" ----------*/ m11 = m1 + 1; pf = f + m1 * fftsz2; for (j = 0, next = pf; j <= m1; j++) { next += fftsz2; for (i = 0; i <= m2; i++) h[m11 * i + j] = *(pf++); pf = next; } free(f); flag_h = 1; for (j = 1; j <= m1; j++) h[j] *= 0.5; for (i = 1; i <= m2; i++) h[i * m11] *= 2.0; } for (i = 0, ph = h; i <= m2; i++) for (j = 0, c2[i] = 0.0; j <= m1; j++) c2[i] += *(ph++) * c1[j]; return; }
static void freqt2(double *c1, const int m1, double *c2, const int m2, const int fftsz, const double a, const double t) { int i, j; double w, b, *ww, *dw, *f, *re, *im, *pf, *pg, *next; int size_g, size_f, fftsz2; static double *g = NULL; static int size2, flag_g = 1; b = M_2PI / (double) fftsz; size_g = (m2 + 1) * (m1 + 1); if (g == NULL) { flag_g = 0; size2 = size_g; g = dgetmem(size2); } else if (size_g != size2) { free(g); flag_g = 0; size2 = size_g; g = dgetmem(size2); } /*------- if "g" is not defined ----------*/ if (flag_g == 0) { ww = dgetmem(fftsz); dw = dgetmem(fftsz); for (j = 0, w = 0.0; j < fftsz; j++, w += b) ww[j] = warp(w, a, t); for (j = 0, w = 0.0; j < fftsz; j++, w += b) dw[j] = derivw(w, a, t); fftsz2 = fftsz + fftsz; /* size of (re + im) */ size_f = (m2 + 1) * fftsz2; /* size of array "f" */ f = dgetmem(size_f); for (i = 0, re = f, im = f + fftsz; i <= m2; i++) { for (j = 0; j < fftsz; j++) *(re++) = cos(ww[j] * i) * dw[j]; for (j = 0; j < fftsz; j++) *(im++) = -sin(ww[j] * i) * dw[j]; re -= fftsz; im -= fftsz; ifft(re, im, fftsz); for (j = 1; j <= m1; j++) re[j] += re[fftsz - j]; re += fftsz2; im += fftsz2; } free(ww); free(dw); /*------- copy "f" to "g" ----------*/ for (i = 0, next = f, pf = f, pg = g; i <= m2; i++) { for (j = 0; j <= m1; j++) *(pg++) = *(pf++); next += fftsz2; pf = next; } free(f); flag_g = 1; for (j = 1; j <= m1; j++) g[j] *= 0.5; for (i = 1; i <= m2; i++) g[i * (m1 + 1)] *= 2.0; } for (i = 0, pg = g; i <= m2; i++) for (j = 0, c2[i] = 0.0; j <= m1; j++) c2[i] += *(pg++) * c1[j]; return; }
static void frqt_a(double *al, const int m, const int fftsz, const double a, const double t) { int i, j; double w, b, *ww, *f, *re, *im, *pf, *pl, *next; int size_l, size_f, fftsz2; static double *l = NULL; static int size1, flag_l = 1; b = M_2PI / (double) fftsz; size_l = m + 1; if (l == NULL) { flag_l = 0; size1 = size_l; l = dgetmem(size1); } else if (size_l != size1) { free(l); flag_l = 0; size1 = size_l; l = dgetmem(size1); } /*------- if "l" is not defined ----------*/ if (flag_l == 0) { ww = dgetmem(fftsz); for (j = 0, w = 0.0; j < fftsz; j++, w += b) ww[j] = warp(w, a, t); fftsz2 = fftsz + fftsz; /* size of (re + im) */ size_f = (m + 1) * fftsz2; /* size of array "f" */ f = dgetmem(size_f); for (i = 0, re = f, im = f + fftsz; i <= m; i++) { for (j = 0; j < fftsz; j++) *(re++) = cos(ww[j] * i); for (j = 0; j < fftsz; j++) *(im++) = -sin(ww[j] * i); re -= fftsz; im -= fftsz; ifft(re, im, fftsz); re += fftsz2; im += fftsz2; } free(ww); /*------- copy "f" to "l" ----------*/ for (i = 0, next = f, pf = f, pl = l; i <= m; i++) { *(pl++) = *pf; next += fftsz2; pf = next; } free(f); flag_l = 1; } movem(l, al, sizeof(*al), m + 1); return; }
static void test_plain_texture () { std::cerr << "Testing 2d texture " << filenames[0] << ", output = " << output_filename << "\n"; const int nchannels = 4; ImageSpec outspec (output_xres, output_yres, nchannels, TypeDesc::HALF); ImageBuf image (output_filename, outspec); ImageBufAlgo::zero (image); Imath::M33f scale; scale.scale (Imath::V2f (0.5, 0.5)); Imath::M33f rot; rot.rotate (radians(30.0f)); Imath::M33f trans; trans.translate (Imath::V2f (0.35f, 0.15f)); Imath::M33f xform = scale * rot * trans; xform.invert(); TextureOptions opt; opt.sblur = blur; opt.tblur = blur; opt.swidth = width; opt.twidth = width; opt.nchannels = nchannels; float localfill = (fill >= 0.0f) ? fill : 1.0f; opt.fill = localfill; if (missing[0] >= 0) opt.missingcolor.init ((float *)&missing, 0); // opt.interpmode = TextureOptions::InterpSmartBicubic; // opt.mipmode = TextureOptions::MipModeAniso; opt.swrap = opt.twrap = TextureOptions::WrapPeriodic; // opt.twrap = TextureOptions::WrapBlack; #if 1 TextureOpt opt1; opt1.sblur = blur; opt1.tblur = blur; opt1.swidth = width; opt1.twidth = width; opt1.nchannels = nchannels; opt1.fill = localfill; if (missing[0] >= 0) opt1.missingcolor = (float *)&missing; opt1.swrap = opt1.twrap = TextureOpt::WrapPeriodic; #endif int shadepoints = blocksize*blocksize; float *s = ALLOCA (float, shadepoints); float *t = ALLOCA (float, shadepoints); Runflag *runflags = ALLOCA (Runflag, shadepoints); float *dsdx = ALLOCA (float, shadepoints); float *dtdx = ALLOCA (float, shadepoints); float *dsdy = ALLOCA (float, shadepoints); float *dtdy = ALLOCA (float, shadepoints); float *result = ALLOCA (float, shadepoints*nchannels); ustring filename = ustring (filenames[0]); TextureSystem::Perthread *perthread_info = texsys->get_perthread_info (); TextureSystem::TextureHandle *texture_handle = texsys->get_texture_handle (filename); for (int iter = 0; iter < iters; ++iter) { if (iters > 1 && filenames.size() > 1) { // Use a different filename for each iteration int texid = std::min (iter, (int)filenames.size()-1); filename = ustring (filenames[texid]); std::cerr << "iter " << iter << " file " << filename << "\n"; } // Iterate over blocks for (int by = 0, b = 0; by < output_yres; by+=blocksize) { for (int bx = 0; bx < output_xres; bx+=blocksize, ++b) { // Trick: switch to other textures on later iterations, if any if (iters == 1 && filenames.size() > 1) { // Use a different filename from block to block filename = ustring (filenames[b % (int)filenames.size()]); } // Process pixels within a block. First save the texture warp // (s,t) and derivatives into SIMD vectors. int idx = 0; for (int y = by; y < by+blocksize; ++y) { for (int x = bx; x < bx+blocksize; ++x) { if (x < output_xres && y < output_yres) { if (nowarp) { s[idx] = (float)x/output_xres * sscale + offset[0]; t[idx] = (float)y/output_yres * tscale + offset[1]; dsdx[idx] = 1.0f/output_xres * sscale; dtdx[idx] = 0; dsdy[idx] = 0; dtdy[idx] = 1.0f/output_yres * tscale; } else { Imath::V3f coord = warp ((float)x/output_xres, (float)y/output_yres, xform); coord.x *= sscale; coord.y *= tscale; coord += offset; Imath::V3f coordx = warp ((float)(x+1)/output_xres, (float)y/output_yres, xform); coordx.x *= sscale; coordx.y *= tscale; coordx += offset; Imath::V3f coordy = warp ((float)x/output_xres, (float)(y+1)/output_yres, xform); coordy.x *= sscale; coordy.y *= tscale; coordy += offset; s[idx] = coord[0]; t[idx] = coord[1]; dsdx[idx] = coordx[0] - coord[0]; dtdx[idx] = coordx[1] - coord[1]; dsdy[idx] = coordy[0] - coord[0]; dtdy[idx] = coordy[1] - coord[1]; } runflags[idx] = RunFlagOn; } else { runflags[idx] = RunFlagOff; } ++idx; } } // Call the texture system to do the filtering. bool ok; if (blocksize == 1) { if (use_handle) ok = texsys->texture (texture_handle, perthread_info, opt1, s[0], t[0], dsdx[0], dtdx[0], dsdy[0], dtdy[0], result); else ok = texsys->texture (filename, opt1, s[0], t[0], dsdx[0], dtdx[0], dsdy[0], dtdy[0], result); } else { ok = texsys->texture (filename, opt, runflags, 0, shadepoints, Varying(s), Varying(t), Varying(dsdx), Varying(dtdx), Varying(dsdy), Varying(dtdy), result); } if (! ok) { std::string e = texsys->geterror (); if (! e.empty()) std::cerr << "ERROR: " << e << "\n"; } for (int i = 0; i < shadepoints*nchannels; ++i) result[i] *= scalefactor; // Save filtered pixels back to the image. idx = 0; for (int y = by; y < by+blocksize; ++y) { for (int x = bx; x < bx+blocksize; ++x) { if (runflags[idx]) { image.setpixel (x, y, result + idx*nchannels); } ++idx; } } } } } if (! image.save ()) std::cerr << "Error writing " << output_filename << " : " << image.geterror() << "\n"; }