/**
* Compute a morph through time by generating appropriate values of t and
* repeatedly calling MorphImages(). Saves the image sequence to disk.
*/
void GenerateMorphFrames(STImage *sourceImage, const std::vector<Feature> &sourceFeatures,
STImage *targetImage, const std::vector<Feature> &targetFeatures,
float a, float b, float p)
{
// iterate and generate each required frame
for (int i = 0; i <= kFrames - 1; ++i)
{
std::cout << "Metamorphosizing frame #" << i << "...";
// **********
// CS148 TODO: Compute a t value for the current frame and generate
// the morphed image here.
// **********
float t = easeFunction(i, kFrames);
printf("\n%f\n", t);
// float t = (float)i / (kFrames-1);
STImage *result = MorphImages(sourceImage, sourceFeatures, targetImage, targetFeatures, t, a, b, p);
// generate a file name to save
std::ostringstream oss;
oss << "frame" << std::setw(3) << std::setfill('0') << i << ".png";
// write and deallocate the morphed image
if (result) {
result->Save(oss.str());
delete result;
}
std::cout << " done." << std::endl;
}
}
void KeyCallback(unsigned char key, int x, int y)
{
switch(key) {
case 's': {
//
// Take a screenshot, and save as screenshot.jpg
//
STImage* screenshot = new STImage(gWindowSizeX, gWindowSizeY);
screenshot->Read(0,0);
screenshot->Save("../../data/images/screenshot.jpg");
delete screenshot;
}
break;
case 'r':
pScene->GetCamera()->Reset();
break;
case 'u':
pScene->GetCamera()->ResetUp();
break;
case 'q':
exit(0);
default:
break;
}
glutPostRedisplay();
}
void KeyCallback(unsigned char key, int x, int y)
{
switch(key) {
case 's': {
//
// Take a screenshot, and save as screenshot.jpg
//
STImage* screenshot = new STImage(gWindowSizeX, gWindowSizeY);
screenshot->Read(0,0);
screenshot->Save("screenshot.jpg");
delete screenshot;
}
break;
case 'r':
resetCamera();
break;
case 'u':
resetUp();
break;
case 'm': // switch between the mesh you create and the mesh from file
mesh = !mesh;
break;
//case 'p': //switch proxy type between sphere and cylinder
// proxyType=!proxyType;
// if(proxyType) gTriangleMesh->CalculateTextureCoordinatesViaSphericalProxy();
// else gTriangleMesh->CalculateTextureCoordinatesViaCylindricalProxy(-1,1,0,0,1);
// break;
case 'n': // switch between normalMapping and displacementMapping
normalMapping = !normalMapping;
break;
case 'f': // switch between smooth shading and flat shading
smooth = !smooth;
break;
//case 'l': // do loop subdivision
// if(mesh){
// gTriangleMesh->LoopSubdivide();
// if(proxyType) gTriangleMesh->CalculateTextureCoordinatesViaSphericalProxy();
// else gTriangleMesh->CalculateTextureCoordinatesViaCylindricalProxy(-1,1,0,0,1);
// }
// else
// gManualTriangleMesh->LoopSubdivide();
// break;
//case 'w':
// gTriangleMesh->Write("output.obj");
// break;
case 'a':
for(unsigned int id=0;id<gTriangleMeshes.size();id++)
gTriangleMeshes[id]->mDrawAxis=!gTriangleMeshes[id]->mDrawAxis;
if(gManualTriangleMesh!=0)
gManualTriangleMesh->mDrawAxis=!gManualTriangleMesh->mDrawAxis;
break;
case 'q':
exit(0);
default:
break;
}
glutPostRedisplay();
}
// Load the cube faces
void LoadCubeFace(GLenum target, char *filename)
{
FILE *file;
// load image and get pixels
STImage *image = new STImage(filename);
const STColor4ub* pixels = image->GetPixels();
// build mipmaps
gluBuild2DMipmaps(target, GL_RGBA,
image->GetWidth(), image->GetHeight(),
GL_RGBA, GL_UNSIGNED_BYTE, pixels);
}
void KeyCallback(unsigned char key, int x, int y)
{
switch(key) {
case 's': {
//
// Take a screenshot, and save as screenshot.jpg
//
STImage* screenshot = new STImage(gWindowSizeX, gWindowSizeY);
screenshot->Read(0,0);
screenshot->Save("screenshot.jpg");
delete screenshot;
}
break;
case 'r':
resetCamera();
break;
case 'm': // switch between the mesh you create and the mesh from file
mesh = !mesh;
break;
case 'p': //switch proxy type between sphere and cylinder
proxyType=!proxyType;
if(proxyType) gTriangleMesh->CalculateTextureCoordinatesViaSphericalProxy();
else gTriangleMesh->CalculateTextureCoordinatesViaCylindricalProxy(-1,1,0,0,1);
break;
case 'n': // switch between normalMapping and displacementMapping
normalMapping = !normalMapping;
break;
case 'f': // switch between smooth shading and flat shading
smooth = !smooth;
break;
case 'l': // do loop subdivision
if(mesh){
gTriangleMesh->LoopSubdivide();
if(proxyType) gTriangleMesh->CalculateTextureCoordinatesViaSphericalProxy();
else gTriangleMesh->CalculateTextureCoordinatesViaCylindricalProxy(-1,1,0,0,1);
}
else
water->LoopSubdivide();
break;
case 'q':
exit(0);
default:
break;
}
glutPostRedisplay();
}
/**
* Compute a linear blend of the pixel colors in two provided images according
* to a parameter t.
*/
STImage *BlendImages(STImage *image1, STImage *image2, float t)
{
int width = image1->GetWidth();
int height = image1->GetHeight();
STImage *result = new STImage(width, height, STColor4ub(255,255,255,255));
for (int x = 0; x < width; x++) {
for (int y = 0; y < height; y++) {
STColor4f pixel1 = STColor4f(image1->GetPixel(x, y));
STColor4f pixel2 = STColor4f(image2->GetPixel(x, y));
STColor4f newPixel = pixel1*(1-t) + pixel2*t;
result->SetPixel(x, y, STColor4ub(newPixel));
}
}
return result;
}
void KeyCallback(unsigned char key, int x, int y)
{
switch(key) {
case 's': {
//
// Take a screenshot, and save as screenshot.jpg
//
STImage* screenshot = new STImage(gWindowSizeX, gWindowSizeY);
screenshot->Read(0,0);
screenshot->Save("screenshot.jpg");
delete screenshot;
}
break;
case 'r':
resetCamera();
break;
case 't':
teapot = !teapot;
break;
case '1': // lake mode
lake = true;
ocean = false;
trampoline = false;
t = 0.0;
InitLakeWaves();
break;
case '2': // ocean mode
lake = false;
ocean = true;
trampoline = false;
t = 0.0;
break;
case '3':
lake = false;
ocean = false;
trampoline = true;
t = 0.0;
break;
case 'q':
exit(0);
default:
break;
}
glutPostRedisplay();
}
STImage *FieldMorph(STImage *image,
const std::vector<Feature> &sourceFeatures,
const std::vector<Feature> &targetFeatures,
float t, float a, float b, float p)
{
int width = image->GetWidth();
int height = image->GetHeight();
STImage *result = new STImage(width, height, STColor4ub(255,255,255,255));
std::vector<Feature> interpolatedFeatures = interpolateFeatures(sourceFeatures, targetFeatures, t);
for (int x = 0; x < width; x++) {
for (int y = 0; y < height; y++) {
STVector2 dispSum = STVector2(0, 0);
float weightsum = 0;
STPoint2 X = STPoint2(x, y);
int numFeatures = sourceFeatures.size();
for (int i = 0; i < numFeatures; i++) {
STPoint2 Pp = sourceFeatures[i].P;
STPoint2 Qp = sourceFeatures[i].Q;
STPoint2 P = interpolatedFeatures[i].P;
STPoint2 Q = interpolatedFeatures[i].Q;
float u = calculateU(X, P, Q);
float v = calculateV(X, P, Q);
STPoint2 Xp = calculateXp(Pp, Qp, u, v);
STVector2 displacement = STVector2(Xp) - STVector2(X);
float dist = calculateDistance(X, P, Q, u, v);
float weight = calculateWeight(Q, P, a, b, p, dist);
dispSum += displacement * weight;
weightsum += weight;
}
STPoint2 Xprime = X + dispSum/weightsum;
result->SetPixel(x, y, interpolatedColor(Xprime, image));
}
}
return result;
}
void KeyCallback(unsigned char key, int x, int y)
{
// TO DO: Any new key press events must be added to this function
switch(key) {
case 'a': {
for(unsigned int id=0;id<gTriangleMeshes.size();id++)
gTriangleMeshes[id]->mDrawAxis=!gTriangleMeshes[id]->mDrawAxis;
if(gManualTriangleMesh!=0)
gManualTriangleMesh->mDrawAxis=!gManualTriangleMesh->mDrawAxis;
}
break;
case 'c': {
// TO DO: Proj3_4 OpenGL
// 1. Add a key press event 'c' that toggles the camera
// between Fly and Orbit mode
// 2. Use Camera::ToggleRotationMode
//------------------------------------------------
pScene->GetCamera()->ToggleRotationMode();
//------------------------------------------------
}
break;
case 'd': {
// TO DO: Proj3_4 OpenGL
// 1. Add a key press event 'd' that toggles the scene
// between ENVIRONMENTMAP and NAVIGATION mode
// 2. Don't forget to change the RenderMode gloabl startMode
// ToggleRenderMode() , set startMode, Setup()
//------------------------------------------------
//------------------------------------------------
}
break;
case 'e': {
// TO DO: Proj3_4 OpenGL
// 1. Add a key press event 'e' that toggles the manipulator
// geometry showing. This makes it easier to select
// parts of the manipulator
// ALL, TRANSONLY, ROTATEONLY
// call ToggleManipGeometry() in the scene class
//------------------------------------------------
//------------------------------------------------
}
break;
case 'f': {// switch between smooth shading and flat shading
smooth = !smooth;
}
break;
case 'k': {
// TO DO: Proj3_4 OpenGL
// 1. Add a key press event 'k' that toggles between local and parent mode
// 2. Use Scene::ToggleManipMode() in scene class
//------------------------------------------------
//------------------------------------------------
}
break;
case 'r': {
pScene->GetCamera()->Reset();
}
break;
case 's': {
//
// Take a screenshot, and save as screenshot.jpg
//
STImage* screenshot = new STImage(gWindowSizeX, gWindowSizeY);
screenshot->Read(0,0);
screenshot->Save("../../data/images/screenshot.jpg");
delete screenshot;
}
break;
// TO:DO do loop subdivision, uncomment this code
// modify it so that it works with your sphere
// simply make sure you are calling the functions
// on the correct mesh.
//---------------------------------
//case 'l':
// if(mesh){
// gTriangleMesh->LoopSubdivide();
// if(proxyType) gTriangleMesh->CalculateTextureCoordinatesViaSphericalProxy();
// else gTriangleMesh->CalculateTextureCoordinatesViaCylindricalProxy(-
case 'm': {// switch between the mesh you create and the mesh from file
mesh = !mesh;
}
break;
case 'n': { // switch between normalMapping and displacementMapping
normalMapping = !normalMapping;
}
break;
case 'u': {
pScene->GetCamera()->ResetUp();
}
break;
case 'w': {
for(unsigned int id=0;id<gTriangleMeshes.size();id++)
gTriangleMeshes[id]->Write("output.obj");
}
break;
case 'q': {
exit(0);
}
default:
break;
}
glutPostRedisplay();
}
void KeyCallback(unsigned char key, int x, int y)
{
// TO DO: Any new key press events must be added to this function
switch(key) {
case 's': {
//
// Take a screenshot, and save as screenshot.jpg
//
STImage* screenshot = new STImage(gWindowSizeX, gWindowSizeY);
screenshot->Read(0,0);
screenshot->Save("../../data/images/screenshot.jpg");
delete screenshot;
}
break;
case 'r':
resetCamera();
break;
case 'u':
resetUp();
break;
case 'm': // switch between the mesh you create and the mesh from file
mesh = !mesh;
break;
case 'n': // switch between normalMapping and displacementMapping
normalMapping = !normalMapping;
break;
case 't':
createSphere();
break;
// TO:DO do loop subdivision, uncomment this code
// modify it so that it works with your sphere
// simply make sure you are calling the functions
// on the correct mesh.
//---------------------------------
case 'l':
if(mesh){
for(int i=0; i<gTriangleMeshes.size(); i++){
gTriangleMeshes[i]->LoopSubdivide();
if(proxyType)
gTriangleMeshes[i]->CalculateTextureCoordinatesViaSphericalProxy();
//else
// gTriangleMeshes[i]->CalculateTextureCoordinatesViaCylindricalProxy();
}
break;
case 'f': // switch between smooth shading and flat shading
smooth = !smooth;
break;
case 'w':
for(unsigned int id=0;id<gTriangleMeshes.size();id++)
gTriangleMeshes[id]->Write("output.obj");
break;
case 'a':
for(unsigned int id=0;id<gTriangleMeshes.size();id++)
gTriangleMeshes[id]->mDrawAxis=!gTriangleMeshes[id]->mDrawAxis;
if(gManualTriangleMesh!=0)
gManualTriangleMesh->mDrawAxis=!gManualTriangleMesh->mDrawAxis;
break;
case 'q':
exit(0);
default:
break;
}
glutPostRedisplay();
}
}
STHDRImage* recover_hdr(vector<Photo>& photos, CameraResponse& response) {
int width,height;
STImage *tmpImage = new STImage(photos[0].filename);
width = tmpImage->GetWidth();
height = tmpImage->GetHeight();
delete tmpImage;
STHDRImage *newImage = new STHDRImage(width,height);
vector< vector<STColor3f> > Ls;
vector< vector<STColor3f> > ws;
vector< vector<STColor3f> > Lw;
for (int i=0;i<width;i++)
{
vector<STColor3f> row;
for (int j=0;j<height;j++)
{
STColor3f zero(0);
row.push_back(zero);
}
Ls.push_back(row);
ws.push_back(row);
Lw.push_back(row);
}
for (int k=0;k<photos.size();k++)
{
//open photo
STImage currentImage(photos[k].filename);
//perform calculations
for (int i=0;i<width;i++)
{
for (int j=0;j<height;j++)
{
STColor4ub currentPixel = currentImage.GetPixel(i, j);
Ls[i][j].r += (response.Weight(currentPixel).r * (response.GetExposure(currentPixel).r - logf(photos[k].shutter) ) );
Ls[i][j].g += (response.Weight(currentPixel).g * (response.GetExposure(currentPixel).g - logf(photos[k].shutter) ) );
Ls[i][j].b += (response.Weight(currentPixel).b * (response.GetExposure(currentPixel).b - logf(photos[k].shutter) ) );
ws[i][j] += response.Weight(currentPixel);
}
}
for (int i=0;i<width;i++)
{
for (int j=0;j<height;j++)
{
Lw[i][j].r = expf(Ls[i][j].r / ws[i][j].r);
Lw[i][j].g = expf(Ls[i][j].g / ws[i][j].g);
Lw[i][j].b = expf(Ls[i][j].b / ws[i][j].b);
newImage->SetPixel(i, j, Lw[i][j]);
}
}
}
return newImage;
}
