jni/filters/tinyplanet.cc

   1 /*
   2  * Copyright (C) 2012 The Android Open Source Project
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *      http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 #include "filters.h"
  18 #include <math.h>
  19
  20 #ifdef __cplusplus
  21 extern "C" {
  22 #endif
  23
  24
  25 #define PI_F 3.141592653589f
  26
  27 class ImageRGBA {
  28  public:
  29   ImageRGBA(unsigned char* image, int width, int height)
  30    : image_(image), width_(width), height_(height) {
  31     width_step_ = width * 4;
  32   }
  33
  34   int Width() const {
  35     return width_;
  36   }
  37
  38   int Height() const {
  39     return height_;
  40   }
  41
  42   // Pixel accessor.
  43   unsigned char* operator()(int x, int y) {
  44     return image_ + y * width_step_ + x * 4;
  45   }
  46   const unsigned char* operator()(int x, int y) const {
  47     return image_ + y * width_step_ + x * 4;
  48   }
  49
  50  private:
  51   unsigned char* image_;
  52   int width_;
  53   int height_;
  54   int width_step_;
  55 };
  56
  57 // Interpolate a pixel in a 3 channel image.
  58 inline void InterpolatePixel(const ImageRGBA &image, float x, float y,
  59                              unsigned char* dest) {
  60   // Get pointers and scale factors for the source pixels.
  61   float ax = x - floor(x);
  62   float ay = y - floor(y);
  63   float axn = 1.0f - ax;
  64   float ayn = 1.0f - ay;
  65   const unsigned char *p = image(x, y);
  66   const unsigned char *p2 = image(x, y + 1);
  67
  68   // Interpolate each image color plane.
  69   dest[0] = static_cast<unsigned char>(axn * ayn * p[0] + ax * ayn * p[4] +
  70              ax * ay * p2[4] + axn * ay * p2[0] + 0.5f);
  71   p++;
  72   p2++;
  73
  74   dest[1] = static_cast<unsigned char>(axn * ayn * p[0] + ax * ayn * p[4] +
  75              ax * ay * p2[4] + axn * ay * p2[0] + 0.5f);
  76   p++;
  77   p2++;
  78
  79   dest[2] = static_cast<unsigned char>(axn * ayn * p[0] + ax * ayn * p[4] +
  80              ax * ay * p2[4] + axn * ay * p2[0] + 0.5f);
  81   p++;
  82   p2++;
  83   dest[3] = 0xFF;
  84 }
  85
  86 // Wrap circular coordinates around the globe
  87 inline float wrap(float value, float dimension) {
  88   return value - (dimension * floor(value/dimension));
  89 }
  90
  91 void StereographicProjection(float scale, float angle, unsigned char* input_image,
  92                              int input_width, int input_height,
  93                              unsigned char* output_image, int output_width,
  94                              int output_height) {
  95   ImageRGBA input(input_image, input_width, input_height);
  96   ImageRGBA output(output_image, output_width, output_height);
  97
  98   const float image_scale = output_width * scale;
  99
 100   for (int x = 0; x < output_width; x++) {
 101     // Center and scale x
 102     float xf = (x - output_width / 2.0f) / image_scale;
 103
 104     for (int y = 0; y < output_height; y++) {
 105       // Center and scale y
 106       float yf = (y - output_height / 2.0f) / image_scale;
 107
 108       // Convert to polar
 109       float r = hypotf(xf, yf);
 110       float theta = angle+atan2(yf, xf);
 111       if (theta>PI_F) theta-=2*PI_F;
 112
 113       // Project onto plane
 114       float phi = 2 * atan(1 / r);
 115       // (theta stays the same)
 116
 117       // Map to panorama image
 118       float px = (theta / (2 * PI_F)) * input_width;
 119       float py = (phi / PI_F) * input_height;
 120
 121       // Wrap around the globe
 122       px = wrap(px, input_width);
 123       py = wrap(py, input_height);
 124
 125       // Write the interpolated pixel
 126       InterpolatePixel(input, px, py, output(x, y));
 127     }
 128   }
 129 }
 130
 131
 132 void JNIFUNCF(ImageFilterTinyPlanet, nativeApplyFilter, jobject bitmap_in, jint width, jint height, jobject bitmap_out, jint output_size, jfloat scale,jfloat angle)
 133 {
 134     char* source = 0;
 135     char* destination = 0;
 136     AndroidBitmap_lockPixels(env, bitmap_in, (void**) &source);
 137     AndroidBitmap_lockPixels(env, bitmap_out, (void**) &destination);
 138     unsigned char * rgb_in = (unsigned char * )source;
 139     unsigned char * rgb_out = (unsigned char * )destination;
 140
 141     StereographicProjection(scale,angle, rgb_in, width, height, rgb_out, output_size, output_size);
 142     AndroidBitmap_unlockPixels(env, bitmap_in);
 143     AndroidBitmap_unlockPixels(env, bitmap_out);
 144 }
 145
 146 #ifdef __cplusplus
 147 }
 148 #endif
 149
 150